This is an automated email from the ASF dual-hosted git repository.
dspavlov pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/ignite-teamcity-bot.git
The following commit(s) were added to refs/heads/master by this push:
new ca8dc7d1 IGNITE-28658: Update TC Bot installation docs and prod
defaults accroding to previous experience (#229)
ca8dc7d1 is described below
commit ca8dc7d16282801e5b395992c8a5b0fa67a83041
Author: ignitetcbot <[email protected]>
AuthorDate: Fri May 15 10:20:43 2026 +0300
IGNITE-28658: Update TC Bot installation docs and prod defaults accroding
to previous experience (#229)
* Update TC Bot installation docs
* update jauncher defaults
---------
Co-authored-by: Dmitriy Pavlov <[email protected]>
---
README.md | 8 +-
docs/install.md | 419 +++++++++++----------
docs/{install.md => testing.md} | 185 +++------
jetty-launcher/build.gradle | 7 +-
migrator/README.md | 10 +-
.../apache/ignite/migrate/GridIntListMigrator.java | 4 +-
6 files changed, 296 insertions(+), 337 deletions(-)
diff --git a/README.md b/README.md
index 147e709d..a9890fd4 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,8 @@ Major use cases are the following:
* MCTGA Bot for slack and for email notifications.
User-facing bot rules and workflows are documented in [TeamCity bot user
guide](docs/teamcity-bot-user-guide.md).
+Production build and deployment are documented in [Build and
installation](docs/install.md).
+Local clean checks and emulated bot runs are documented in
[Testing](docs/testing.md).
This tool is available on
[https://mtcga.gridgain.com/](https://mtcga.gridgain.com/) - requires apache CI
credentials.
@@ -75,10 +77,6 @@ Please install following components for development using
IntelliJ IDEA
* Apply [Code Inspection
Profile](https://cwiki.apache.org/confluence/display/IGNITE/Coding+Guidelines#CodingGuidelines-C.CodeInspection)
* Configure [IDEA
Codestyle](https://cwiki.apache.org/confluence/display/IGNITE/Coding+Guidelines#CodingGuidelines-A.ConfigureIntelliJIDEAcodestyle)
-### Build and installation
-Build, production installation, Linux service setup, and Windows
production-check commands are documented in
-[Build and installation](docs/install.md).
-
### Internal Design
Main bot logic is placed in [ignite-tc-helper-web](ignite-tc-helper-web)
module.
[jetty-launcher](jetty-launcher) is an application module to start bot in
production.
@@ -139,5 +137,5 @@ The same migrator can also be run as a standalone tool from
the `migrator` modul
standalone module uses the same Ignite version as the rest of the project
through the shared `ignVer` Gradle property.
Heavyweight persistent-storage integration tests are excluded from the regular
`test` and `build` tasks. Run them
-explicitly with `./gradlew :migrator:integrationTest --no-daemon` when
checking old Ignite 2.14 persistent storage
+explicitly with `gradle :migrator:integrationTest --no-daemon` when checking
old Ignite 2.14 persistent storage
compatibility or migration recovery for corrupted binary metadata.
diff --git a/docs/install.md b/docs/install.md
index b503cd88..b80c747a 100644
--- a/docs/install.md
+++ b/docs/install.md
@@ -1,238 +1,263 @@
# Build and installation
-Use Java 17. Build everything through the Gradle wrapper:
+This is a deliberately plain production runbook.
+Examples use only local paths and assume the service user is
+`teamcity`.
+## 1. Prepare directories
+
+Create the base directory once.
+
+```bash
+sudo mkdir -p /data/tcbot/work
+```
+
+## 2. Get the source code
+
+Clone the repository if it is not there yet:
+
+```bash
+cd /data/tcbot
+git clone https://github.com/apache/ignite-teamcity-bot.git ignite-teamcity-bot
+```
+
+Before each build, update the checkout:
+
+```bash
+cd /data/tcbot/ignite-teamcity-bot
+git fetch origin master
+git switch master
+git pull --ff-only origin master
+```
+
+## 3. Build the distribution
+
+Use Java 17. Build with Gradle. This has been tested with Gradle 9.5 and
Gradle 9.4.1.
+
+```bash
+cd /data/tcbot/ignite-teamcity-bot
+gradle clean build --no-daemon
+gradle :jetty-launcher:clean :jetty-launcher:distZip --no-daemon
+```
+
+The distribution archive is:
+
+```bash
+/data/tcbot/ignite-teamcity-bot/jetty-launcher/build/distributions/jetty-launcher.zip
```
-./gradlew clean build --no-daemon
-./gradlew :jetty-launcher:clean :jetty-launcher:distZip --no-daemon
+
+It contains `bin`, `lib`, and `war/ignite-tc-helper-web.war`.
+
+## 4. Stop the current service
+
+Stop TC Bot before copying or migrating anything:
+
+```bash
+sudo systemctl stop tcbot
+sudo systemctl status tcbot
+pgrep -af 'jetty-launcher|TcHelperJettyLauncher' || true
```
-On Windows use the same commands with `gradlew.bat`:
+Do not continue until the Java process is gone.
+
+## 5. Back up the old runtime and data
+Create one timestamped backup directory. Keep the old runtime and the whole
work directory together, so rollback can
+use the same files that were running before the upgrade.
+
+```bash
+TS="$(date +%Y%m%d-%H%M%S)"
+BACKUP="/data/tcbot/backup_for_update/$TS"
+mkdir -p "$BACKUP"
```
-gradlew.bat clean build --no-daemon
-gradlew.bat :jetty-launcher:clean :jetty-launcher:distZip --no-daemon
+
+Back up the live runtime:
+
+```bash
+if [ -d /data/tcbot/jetty-launcher ]; then
+ cp -a /data/tcbot/jetty-launcher "$BACKUP/jetty-launcher"
+fi
```
-The web distribution is
`jetty-launcher/build/distributions/jetty-launcher.zip`. It contains `bin`,
`lib`, and
-`war/ignite-tc-helper-web.war`.
+Back up the live work directory. This is the database backup too, because
Ignite persistence is inside `work`:
-The production launcher creates `work/diagnostic` on startup. JVM heap dumps
and fatal error logs are written there:
-`java_pid<pid>.hprof` for OOME heap dumps and `hs_err_pid<pid>.log` for JVM
crash logs.
+```bash
+cp -a /data/tcbot/work "$BACKUP/work"
+```
+
+Back up the generated launch scripts from the old runtime:
+
+```bash
+mkdir -p "$BACKUP/scripts"
+if [ -d /data/tcbot/jetty-launcher/bin ]; then
+ cp -a /data/tcbot/jetty-launcher/bin "$BACKUP/scripts/bin"
+fi
+```
+
+Write a tiny restore note into the backup:
+
+```bash
+{
+ echo "Created: $TS"
+ echo "Runtime: $BACKUP/jetty-launcher"
+ echo "Work: $BACKUP/work"
+ echo "Launch scripts: $BACKUP/scripts"
+} > "$BACKUP/README.txt"
+```
-## Linux service
+## 6. Install the new runtime
-Unpack the distribution and put production config into `work`:
+Install the new archive into a staging directory first:
+```bash
+cd /data/tcbot/ignite-teamcity-bot
+rm -rf /data/tcbot/jetty-launcher.new
+unzip -oq jetty-launcher/build/distributions/jetty-launcher.zip -d
/data/tcbot/jetty-launcher.new
```
-sudo mkdir -p /opt/ignite-teamcity-bot/releases /opt/ignite-teamcity-bot/work
-sudo unzip -oq jetty-launcher.zip -d /opt/ignite-teamcity-bot/releases
-sudo ln -sfn /opt/ignite-teamcity-bot/releases/jetty-launcher
/opt/ignite-teamcity-bot/current
-sudo cp branches.json /opt/ignite-teamcity-bot/work/branches.json
+
+The archive unpacks to `/data/tcbot/jetty-launcher.new/jetty-launcher`.
Replace the live runtime only after the backup
+exists:
+
+```bash
+rm -rf /data/tcbot/jetty-launcher
+mv /data/tcbot/jetty-launcher.new/jetty-launcher /data/tcbot/jetty-launcher
+rmdir /data/tcbot/jetty-launcher.new
```
-`/etc/systemd/system/tc-bot-service.service`:
+Make sure the live config exists:
+```bash
+if [ ! -f /data/tcbot/work/branches.json ]; then
+ cp /data/tcbot/ignite-teamcity-bot/conf/branches.json
/data/tcbot/work/branches.json
+fi
```
+
+## 7. Linux service
+
+Create or update `/etc/systemd/system/tcbot.service`:
+
+```ini
[Unit]
Description=Ignite TeamCity Bot
After=network-online.target
[Service]
Type=simple
-User=tc-bot
-Group=tc-bot
-WorkingDirectory=/opt/ignite-teamcity-bot/current/bin
+User=teamcity
+Group=teamcity
+WorkingDirectory=/data/tcbot/jetty-launcher/bin
Environment="JAVA_HOME=/usr/lib/jvm/java-17"
-Environment="TCBOT_WORK_DIR=/opt/ignite-teamcity-bot/work"
-ExecStart=/opt/ignite-teamcity-bot/current/bin/jetty-launcher
+Environment="TCBOT_WORK_DIR=/data/tcbot/work"
+ExecStart=/data/tcbot/jetty-launcher/bin/jetty-launcher
Restart=on-failure
[Install]
WantedBy=multi-user.target
```
-Start it:
+Reload systemd and start the service:
-```
+```bash
sudo systemctl daemon-reload
-sudo systemctl enable tc-bot-service
-sudo systemctl restart tc-bot-service
-sudo systemctl status tc-bot-service
-```
-
-Use generated `bin/jetty-launcher`; it already contains the Java 17 module
options required by Ignite and Guice.
-
-## Production-like clean checks
-
-Use a separate clean checkout. Set `PR_REF` for PR checks before running
PR-specific tasks. The heavyweight
-persistent-storage integration tests are disabled by default: uncomment
`RUN_INTEGRATION_TESTS=1` when the local PR
-check must also cover legacy Ignite storage and migration recovery. The
integration task is executed only after the
-optional PR/ref checkout, so the checked ref defines whether the task exists.
-
-<details>
-<summary>Windows</summary>
-
-```bat
-@echo off
-setlocal
-
-set "CHECK_ROOT=%~dp0"
-set "REPO=%CHECK_ROOT%ignite-teamcity-bot-check"
-set "DIST=%CHECK_ROOT%tc-bot-prod-check"
-set "PR_REF="
-rem set "PR_REF=pull/200/head"
-set "RUN_INTEGRATION_TESTS="
-rem set "RUN_INTEGRATION_TESTS=1"
-
-if not exist "%REPO%\.git" git clone
https://github.com/apache/ignite-teamcity-bot.git "%REPO%" || exit /b 1
-cd /d "%REPO%" || exit /b 1
-git fetch origin master || exit /b 1
-git switch master || exit /b 1
-git reset --hard origin/master || exit /b 1
-git clean -fdx || exit /b 1
-
-if not "%PR_REF%"=="" (
- git branch -D pr-check 2>NUL
- git fetch origin "%PR_REF%:refs/heads/pr-check" || exit /b 1
- git switch pr-check || exit /b 1
-)
-
-call gradlew.bat clean build --no-daemon || exit /b 1
-if "%RUN_INTEGRATION_TESTS%"=="1" (
- call gradlew.bat :migrator:integrationTest --no-daemon || exit /b 1
-) else (
- echo Skipping migrator integration tests. Uncomment RUN_INTEGRATION_TESTS
to enable.
-)
-call gradlew.bat :jetty-launcher:clean :jetty-launcher:distZip --no-daemon ||
exit /b 1
-
-powershell -NoProfile -ExecutionPolicy Bypass -Command "Remove-Item
-LiteralPath '%DIST%' -Recurse -Force -ErrorAction SilentlyContinue;
Expand-Archive -LiteralPath
'jetty-launcher\build\distributions\jetty-launcher.zip' -DestinationPath
'%DIST%' -Force" || exit /b 1
-powershell -NoProfile -ExecutionPolicy Bypass -Command "New-Item -ItemType
Directory -Force -Path '%DIST%\jetty-launcher\work' | Out-Null" || exit /b 1
-copy /Y "conf\branches.json" "%DIST%\jetty-launcher\work\branches.json" ||
exit /b 1
-
-cd /d "%DIST%\jetty-launcher\bin" || exit /b 1
-call jetty-launcher.bat
-```
-
-</details>
-
-### Emulated bot clean check
-
-Use this variant for a quick clean build of any PR followed by a local
emulated TC Bot UI. It uses a separate checkout,
-does not launch the production bot, and starts the integration-test launcher
with local GitHub/JIRA/TeamCity emulators
-on `http://127.0.0.1:5555/`. Unit tests and emulated integration tests are
opt-in flags, so the default path stays fast
-before opening the UI.
-
-```bat
-@echo off
-setlocal
-
-set "CHECK_ROOT=%~dp0"
-set "REPO=%CHECK_ROOT%ignite-teamcity-bot-emulated-check"
-if not "%~1"=="" set "PR_REF=%~1"
-rem Usage:
-rem checkie.bat pull/225/head
-rem checkie.bat 225
-rem set "RUN_TESTS=1"
-rem set "RUN_EMULATED_TESTS=1"
-rem set "TEST_FILTER=--tests
org.apache.ignite.tcbot.integration.BotLoginTriggerQueueFlowTest"
-
-if "%PR_REF%"=="" (
- echo Usage: %~nx0 ^<PR number or ref^>
- echo Example: %~nx0 225
- echo Example: %~nx0 pull/225/head
- exit /b 2
-)
-
-echo %PR_REF%| findstr /R "^[0-9][0-9]*$" >NUL
-if "%ERRORLEVEL%"=="0" set "PR_REF=pull/%PR_REF%/head"
-
-if not exist "%REPO%\.git" git clone
https://github.com/apache/ignite-teamcity-bot.git "%REPO%" || exit /b 1
-cd /d "%REPO%" || exit /b 1
-git fetch origin master || exit /b 1
-git switch master || exit /b 1
-git reset --hard origin/master || exit /b 1
-git clean -fdx || exit /b 1
-
-if not "%PR_REF%"=="" (
- git branch -D pr-emulated-check 2>NUL
- git fetch origin "%PR_REF%:refs/heads/pr-emulated-check" || exit /b 1
- git switch pr-emulated-check || exit /b 1
-)
-
-if "%RUN_TESTS%"=="1" (
- call gradlew.bat clean build --no-daemon || exit /b 1
-) else (
- call gradlew.bat clean assemble --no-daemon || exit /b 1
-)
-
-if "%RUN_EMULATED_TESTS%"=="1" (
- call gradlew.bat :tcbot-integration-tests:integrationTest %TEST_FILTER%
--no-daemon || exit /b 1
-) else (
- echo Skipping emulated integration tests. Set RUN_EMULATED_TESTS=1 to
enable.
-)
-
-echo.
-echo Starting emulated TC Bot UI:
-echo http://127.0.0.1:5555/
-echo Username: ignite.tester
-echo Password: ignite-password
-echo.
-call gradlew.bat :tcbot-integration-tests:runEmulatedBot --no-daemon || exit
/b 1
-```
-
-When `RUN_EMULATED_TESTS=1`, the emulated integration task builds the WAR,
starts the production-like launcher on an
-isolated port, starts separate Python emulators for GitHub, JIRA, and
TeamCity, and then shuts them down after the test
-JVM exits. The final `runEmulatedBot` step starts the same emulator-backed bot
for manual UI checks and keeps running
-until the process is stopped.
-
-<details>
-<summary>Linux</summary>
-
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO="${REPO:-$SCRIPT_DIR/ignite-teamcity-bot-check}"
-DIST="${DIST:-$SCRIPT_DIR/tc-bot-prod-check}"
-PR_REF="${PR_REF:-}"
-# PR_REF="pull/200/head"
-RUN_INTEGRATION_TESTS="${RUN_INTEGRATION_TESTS:-}"
-# RUN_INTEGRATION_TESTS=1
-
-if [ ! -d "$REPO/.git" ]; then
- git clone https://github.com/apache/ignite-teamcity-bot.git "$REPO"
-fi
+sudo systemctl enable tcbot
+sudo systemctl start tcbot
+sudo systemctl status tcbot
+```
-cd "$REPO"
-git fetch origin master
-git switch master
-git reset --hard origin/master
-git clean -fdx
+The generated `bin/jetty-launcher` already contains the Java options required
by the runtime. Do not duplicate those
+options in the systemd unit unless the generated script cannot be used.
-if [ -n "$PR_REF" ]; then
- git branch -D pr-check 2>/dev/null || true
- git fetch origin "$PR_REF:refs/heads/pr-check"
- git switch pr-check
-fi
+The production launcher creates `/data/tcbot/work/diagnostic` on startup. JVM
heap dumps and fatal error logs are
+written there as `java_pid<pid>.hprof` and `hs_err_pid<pid>.log`.
-./gradlew clean build --no-daemon
-if [ "$RUN_INTEGRATION_TESTS" = "1" ]; then
- ./gradlew :migrator:integrationTest --no-daemon
-else
- echo "Skipping migrator integration tests. Set RUN_INTEGRATION_TESTS=1 to
enable."
-fi
-./gradlew :jetty-launcher:clean :jetty-launcher:distZip --no-daemon
+## 8. Check after start
+
+Check logs first:
+
+```bash
+journalctl -u tcbot -n 200 --no-pager
+ls -la /data/tcbot/work
+ls -la /data/tcbot/work/diagnostic
+```
+
+If the bot starts and opens the database, keep the backup. Do not delete it
immediately after a major Java or Ignite
+upgrade.
+
+## 9. Rollback
-rm -rf "$DIST"
-mkdir -p "$DIST"
-unzip -oq jetty-launcher/build/distributions/jetty-launcher.zip -d "$DIST"
-mkdir -p "$DIST/jetty-launcher/work"
-cp conf/branches.json "$DIST/jetty-launcher/work/branches.json"
+Rollback uses the backup made in step 5.
-cd "$DIST/jetty-launcher/bin"
-./jetty-launcher
+```bash
+sudo systemctl stop tcbot
+TS="<backup timestamp>"
+BACKUP="/data/tcbot/backup_for_update/$TS"
+
+rm -rf /data/tcbot/jetty-launcher
+cp -a "$BACKUP/jetty-launcher" /data/tcbot/jetty-launcher
+
+rm -rf /data/tcbot/work
+cp -a "$BACKUP/work" /data/tcbot/work
+
+sudo systemctl start tcbot
+sudo systemctl status tcbot
```
-</details>
+If the rollback target is a very old version, restore and use the old Java
version from the same backup notes. Do not
+try to run a 2022-era runtime with the new Java 17 service file unless it was
already tested that way.
+
+## 10. Migration from old 2022-era installations
+
+Older deployments may have been built and run with Java 8 or Java 11 and an
old Gradle version. Treat that upgrade as a
+migration, not as a simple overwrite.
+
+1. Keep the old environment available.
+
+ Before changing the live service, record where the old Java and old runtime
are:
+
+ ```bash
+ readlink -f "$(command -v java)"
+ java -version
+ ls -la /data/tcbot
+ ```
+
+ If rollback is needed, use the old runtime backup together with the old
Java and old Gradle versions. Make sure the
+ old Gradle is still available in `PATH` before relying on rollback or on
rebuilding the old version. Build the new
+ checkout with Java 17 and a tested Gradle version: 9.5 or 9.4.1. Do not
assume the old backup will run correctly on
+ Java 17.
+
+ If several historical builds must stay available, prefer versioned runtime
directories and a symlink, for example
+ `latest -> 2.17`.
+
+2. Install the new source and new runtime into new paths first.
+
+ Use separate new directories for the checkout, runtime, and work directory.
Do not delete the old runtime directory
+ until the new service has started successfully and the backup has been
verified.
+
+3. Stop the old bot and back up everything.
+
+ Back up the old runtime and the whole old work directory before touching
the database. The important database files
+ are inside the work directory, commonly under `work/db` for current
versions and sometimes under `work/tcbot_srv` in
+ old versions.
+
+4. Copy the old work directory into the new location.
+
+ If the old work directory is elsewhere, copy it to `/data/tcbot/work` while
the bot is stopped:
+
+ ```bash
+ rm -rf /data/tcbot/work
+ cp -a <old-work-dir> /data/tcbot/work
+ ```
+
+5. Start the new Java 17 service.
+
+ Start with the systemd unit from this document. Watch `journalctl -u tcbot`
and `/data/tcbot/work/tcbot_logs`.
+ The first start may run built-in database checks and migrations during
Ignite startup; let it finish instead of
+ restarting repeatedly. Do not run the offline migrator directly as part of
the normal installation procedure.
+
+6. Roll back as a full set if the migration fails.
+
+ Stop the new service, restore the old runtime and old work directory from
the same timestamped backup, and start it
+ with the old Java/runtime setup. Do not restore only the runtime while
keeping a database already opened or migrated
+ by the new version.
+
+Local clean checks and emulated bot runs are documented in
[Testing](testing.md).
diff --git a/docs/install.md b/docs/testing.md
similarity index 66%
copy from docs/install.md
copy to docs/testing.md
index b503cd88..cd8f6d4e 100644
--- a/docs/install.md
+++ b/docs/testing.md
@@ -1,67 +1,4 @@
-# Build and installation
-
-Use Java 17. Build everything through the Gradle wrapper:
-
-```
-./gradlew clean build --no-daemon
-./gradlew :jetty-launcher:clean :jetty-launcher:distZip --no-daemon
-```
-
-On Windows use the same commands with `gradlew.bat`:
-
-```
-gradlew.bat clean build --no-daemon
-gradlew.bat :jetty-launcher:clean :jetty-launcher:distZip --no-daemon
-```
-
-The web distribution is
`jetty-launcher/build/distributions/jetty-launcher.zip`. It contains `bin`,
`lib`, and
-`war/ignite-tc-helper-web.war`.
-
-The production launcher creates `work/diagnostic` on startup. JVM heap dumps
and fatal error logs are written there:
-`java_pid<pid>.hprof` for OOME heap dumps and `hs_err_pid<pid>.log` for JVM
crash logs.
-
-## Linux service
-
-Unpack the distribution and put production config into `work`:
-
-```
-sudo mkdir -p /opt/ignite-teamcity-bot/releases /opt/ignite-teamcity-bot/work
-sudo unzip -oq jetty-launcher.zip -d /opt/ignite-teamcity-bot/releases
-sudo ln -sfn /opt/ignite-teamcity-bot/releases/jetty-launcher
/opt/ignite-teamcity-bot/current
-sudo cp branches.json /opt/ignite-teamcity-bot/work/branches.json
-```
-
-`/etc/systemd/system/tc-bot-service.service`:
-
-```
-[Unit]
-Description=Ignite TeamCity Bot
-After=network-online.target
-
-[Service]
-Type=simple
-User=tc-bot
-Group=tc-bot
-WorkingDirectory=/opt/ignite-teamcity-bot/current/bin
-Environment="JAVA_HOME=/usr/lib/jvm/java-17"
-Environment="TCBOT_WORK_DIR=/opt/ignite-teamcity-bot/work"
-ExecStart=/opt/ignite-teamcity-bot/current/bin/jetty-launcher
-Restart=on-failure
-
-[Install]
-WantedBy=multi-user.target
-```
-
-Start it:
-
-```
-sudo systemctl daemon-reload
-sudo systemctl enable tc-bot-service
-sudo systemctl restart tc-bot-service
-sudo systemctl status tc-bot-service
-```
-
-Use generated `bin/jetty-launcher`; it already contains the Java 17 module
options required by Ignite and Guice.
+# Testing
## Production-like clean checks
@@ -79,7 +16,7 @@ setlocal
set "CHECK_ROOT=%~dp0"
set "REPO=%CHECK_ROOT%ignite-teamcity-bot-check"
-set "DIST=%CHECK_ROOT%tc-bot-prod-check"
+set "DIST=%CHECK_ROOT%tcbot-check-runtime"
set "PR_REF="
rem set "PR_REF=pull/200/head"
set "RUN_INTEGRATION_TESTS="
@@ -98,13 +35,13 @@ if not "%PR_REF%"=="" (
git switch pr-check || exit /b 1
)
-call gradlew.bat clean build --no-daemon || exit /b 1
+call gradle clean build --no-daemon || exit /b 1
if "%RUN_INTEGRATION_TESTS%"=="1" (
- call gradlew.bat :migrator:integrationTest --no-daemon || exit /b 1
+ call gradle :migrator:integrationTest --no-daemon || exit /b 1
) else (
echo Skipping migrator integration tests. Uncomment RUN_INTEGRATION_TESTS
to enable.
)
-call gradlew.bat :jetty-launcher:clean :jetty-launcher:distZip --no-daemon ||
exit /b 1
+call gradle :jetty-launcher:clean :jetty-launcher:distZip --no-daemon || exit
/b 1
powershell -NoProfile -ExecutionPolicy Bypass -Command "Remove-Item
-LiteralPath '%DIST%' -Recurse -Force -ErrorAction SilentlyContinue;
Expand-Archive -LiteralPath
'jetty-launcher\build\distributions\jetty-launcher.zip' -DestinationPath
'%DIST%' -Force" || exit /b 1
powershell -NoProfile -ExecutionPolicy Bypass -Command "New-Item -ItemType
Directory -Force -Path '%DIST%\jetty-launcher\work' | Out-Null" || exit /b 1
@@ -116,7 +53,58 @@ call jetty-launcher.bat
</details>
-### Emulated bot clean check
+<details>
+<summary>Linux</summary>
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO="${REPO:-$SCRIPT_DIR/ignite-teamcity-bot-check}"
+DIST="${DIST:-$SCRIPT_DIR/tcbot-check-runtime}"
+PR_REF="${PR_REF:-}"
+# PR_REF="pull/200/head"
+RUN_INTEGRATION_TESTS="${RUN_INTEGRATION_TESTS:-}"
+# RUN_INTEGRATION_TESTS=1
+
+if [ ! -d "$REPO/.git" ]; then
+ git clone https://github.com/apache/ignite-teamcity-bot.git "$REPO"
+fi
+
+cd "$REPO"
+git fetch origin master
+git switch master
+git reset --hard origin/master
+git clean -fdx
+
+if [ -n "$PR_REF" ]; then
+ git branch -D pr-check 2>/dev/null || true
+ git fetch origin "$PR_REF:refs/heads/pr-check"
+ git switch pr-check
+fi
+
+gradle clean build --no-daemon
+if [ "$RUN_INTEGRATION_TESTS" = "1" ]; then
+ gradle :migrator:integrationTest --no-daemon
+else
+ echo "Skipping migrator integration tests. Set RUN_INTEGRATION_TESTS=1 to
enable."
+fi
+gradle :jetty-launcher:clean :jetty-launcher:distZip --no-daemon
+
+rm -rf "$DIST"
+mkdir -p "$DIST"
+unzip -oq jetty-launcher/build/distributions/jetty-launcher.zip -d "$DIST"
+mkdir -p "$DIST/jetty-launcher/work"
+cp conf/branches.json "$DIST/jetty-launcher/work/branches.json"
+
+cd "$DIST/jetty-launcher/bin"
+./jetty-launcher
+```
+
+</details>
+
+## Emulated bot clean check
Use this variant for a quick clean build of any PR followed by a local
emulated TC Bot UI. It uses a separate checkout,
does not launch the production bot, and starts the integration-test launcher
with local GitHub/JIRA/TeamCity emulators
@@ -161,13 +149,13 @@ if not "%PR_REF%"=="" (
)
if "%RUN_TESTS%"=="1" (
- call gradlew.bat clean build --no-daemon || exit /b 1
+ call gradle clean build --no-daemon || exit /b 1
) else (
- call gradlew.bat clean assemble --no-daemon || exit /b 1
+ call gradle clean assemble --no-daemon || exit /b 1
)
if "%RUN_EMULATED_TESTS%"=="1" (
- call gradlew.bat :tcbot-integration-tests:integrationTest %TEST_FILTER%
--no-daemon || exit /b 1
+ call gradle :tcbot-integration-tests:integrationTest %TEST_FILTER%
--no-daemon || exit /b 1
) else (
echo Skipping emulated integration tests. Set RUN_EMULATED_TESTS=1 to
enable.
)
@@ -178,61 +166,10 @@ echo http://127.0.0.1:5555/
echo Username: ignite.tester
echo Password: ignite-password
echo.
-call gradlew.bat :tcbot-integration-tests:runEmulatedBot --no-daemon || exit
/b 1
+call gradle :tcbot-integration-tests:runEmulatedBot --no-daemon || exit /b 1
```
When `RUN_EMULATED_TESTS=1`, the emulated integration task builds the WAR,
starts the production-like launcher on an
isolated port, starts separate Python emulators for GitHub, JIRA, and
TeamCity, and then shuts them down after the test
JVM exits. The final `runEmulatedBot` step starts the same emulator-backed bot
for manual UI checks and keeps running
until the process is stopped.
-
-<details>
-<summary>Linux</summary>
-
-```bash
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO="${REPO:-$SCRIPT_DIR/ignite-teamcity-bot-check}"
-DIST="${DIST:-$SCRIPT_DIR/tc-bot-prod-check}"
-PR_REF="${PR_REF:-}"
-# PR_REF="pull/200/head"
-RUN_INTEGRATION_TESTS="${RUN_INTEGRATION_TESTS:-}"
-# RUN_INTEGRATION_TESTS=1
-
-if [ ! -d "$REPO/.git" ]; then
- git clone https://github.com/apache/ignite-teamcity-bot.git "$REPO"
-fi
-
-cd "$REPO"
-git fetch origin master
-git switch master
-git reset --hard origin/master
-git clean -fdx
-
-if [ -n "$PR_REF" ]; then
- git branch -D pr-check 2>/dev/null || true
- git fetch origin "$PR_REF:refs/heads/pr-check"
- git switch pr-check
-fi
-
-./gradlew clean build --no-daemon
-if [ "$RUN_INTEGRATION_TESTS" = "1" ]; then
- ./gradlew :migrator:integrationTest --no-daemon
-else
- echo "Skipping migrator integration tests. Set RUN_INTEGRATION_TESTS=1 to
enable."
-fi
-./gradlew :jetty-launcher:clean :jetty-launcher:distZip --no-daemon
-
-rm -rf "$DIST"
-mkdir -p "$DIST"
-unzip -oq jetty-launcher/build/distributions/jetty-launcher.zip -d "$DIST"
-mkdir -p "$DIST/jetty-launcher/work"
-cp conf/branches.json "$DIST/jetty-launcher/work/branches.json"
-
-cd "$DIST/jetty-launcher/bin"
-./jetty-launcher
-```
-
-</details>
diff --git a/jetty-launcher/build.gradle b/jetty-launcher/build.gradle
index 66cd2db8..3939afb9 100644
--- a/jetty-launcher/build.gradle
+++ b/jetty-launcher/build.gradle
@@ -21,15 +21,14 @@ apply plugin: 'application'
application {
mainClass = 'org.apache.ignite.ci.TcHelperJettyLauncher'
applicationDefaultJvmArgs = igniteJava17JvmArgs + ["-Dfile.encoding=UTF-8",
-
"-Dteamcity.bot.regionsize=16", // 16g Durable Memory region
-
"-Dhttp.maxConnections=30",
+
"-Dteamcity.bot.regionsize=32", // 32g Durable Memory region
+
"-Dhttp.maxConnections=100",
"-server",
- "-Xmx16g",
+ "-Xmx31g",
"-XX:+AlwaysPreTouch",
"-XX:+UseG1GC",
"-XX:+ScavengeBeforeFullGC",
"-XX:+UseStringDeduplication",
-
"-Djava.rmi.server.hostname=app02",
"-Dcom.sun.management.jmxremote",
"-Dcom.sun.management.jmxremote.port=9010",
"-Dcom.sun.management.jmxremote.local.only=false",
diff --git a/migrator/README.md b/migrator/README.md
index cf0a946b..22d2f3ae 100644
--- a/migrator/README.md
+++ b/migrator/README.md
@@ -13,22 +13,22 @@ Safety:
Requirements:
- JDK 11+
-- Gradle wrapper from tcbot repo
+- Gradle 9.5 or 9.4.1
- New GridIntList on classpath of migrator
(org.apache.ignite.tcbot.common.util.GridIntList)
Build:
- From repo root:
- - ```./gradlew -p migrator clean build```
+ - ```gradle -p migrator clean build```
Quick start (macOS/Linux):
1) Backup work:
- ```cp -a </path/to/tcbot/work> </path/to/work_backup>```
2) Dry-run with verbose report (no changes apply):
- ```export IGNITE_WORK_DIR=</path/to/work_backup>```
- - ```./gradlew -p migrator run --args="--verbose"```
+ - ```gradle -p migrator run --args="--verbose"```
3) Apply (write changes):
- ```export IGNITE_WORK_DIR=</path/to/work_backup>```
- - ```./gradlew -p migrator run --args="--apply"```
+ - ```gradle -p migrator run --args="--apply"```
- Optional: focus on a cache: `````--cache <cacheName>`````
CLI arguments:
@@ -56,4 +56,4 @@ Verification:
Notes:
- The migrator guards recursion (MAX_DEPTH=32). It logs and skips overly deep
branches to stay robust. MAX_DEPTH is
eligible to be tuned due specific cache.
-- The tool logs with SLF4J (console). Deteministic iteration order is
preserved for Set/Map to keep binary output stable.
\ No newline at end of file
+- The tool logs with SLF4J (console). Deteministic iteration order is
preserved for Set/Map to keep binary output stable.
diff --git
a/migrator/src/main/java/org/apache/ignite/migrate/GridIntListMigrator.java
b/migrator/src/main/java/org/apache/ignite/migrate/GridIntListMigrator.java
index 93d2ba7b..c1b0632f 100644
--- a/migrator/src/main/java/org/apache/ignite/migrate/GridIntListMigrator.java
+++ b/migrator/src/main/java/org/apache/ignite/migrate/GridIntListMigrator.java
@@ -52,8 +52,8 @@ import java.util.concurrent.atomic.AtomicLong;
* <p>
* Usage:
* export IGNITE_WORK_DIR=/abs/path/to/work_backup
- * ./gradlew -p migrator run --args="--verbose --report 200" # dry run
with verbose report
- * ./gradlew -p migrator run --args="--apply --report 50000" # apply to
all caches
+ * gradle -p migrator run --args="--verbose --report 200" # dry run with
verbose report
+ * gradle -p migrator run --args="--apply --report 50000" # apply to all
caches
*/
public final class GridIntListMigrator {
