Pure Chain Update

Update a local legend-pure + legend-engine checkout

Run this by hand, one project at a time. There is no script: the chain breaks in a different place every time — a conflict, a version pin that didn't take, a SNAPSHOT nobody published — and each needs a judgment call. Automating it produced a run that reported success while leaving the real problem buried in a build.log.

Work the steps below per project, in dependency order, and stop at the first thing that looks wrong rather than pressing on to the next project.

The chain

legend-pure  ←  legend-engine

Same DAG as config/projects.json (pure-lsp-roots --list prints it with your checkout paths). Build upstream first.

Which projects to rebuild. If you changed legend-pure, you must rebuild it and legend-engine afterwards — each layer copies Pure sources and generated Java into its own jars, so an upstream change stays invisible downstream until the dependent is rebuilt. A change to legend-engine only requires rebuilding legend-engine itself.

Checkout paths resolve as everywhere else in this plugin: $<rootEnv> ($LEGEND_PURE_ROOT, $LEGEND_ENGINE_ROOT) if set, else $HOME/<root> from the registry.

Per project, in order

1. Sync git

Check for a rebase or merge already in progress first (git -C <path> status) — one left over from a previous attempt means an earlier conflict was never resolved; finish or abort it before continuing.

If the tree is dirty, commit a checkpoint rather than stashing — it survives a rebase cleanly and is trivial to back out with git reset --soft HEAD~1:

git -C <path> add -A && git -C <path> commit -m "WIP: temp commit before chain sync"

Resolve the default branch; do not assume master. legend-pure and legend-engine use finos-master, while origin also carries an unrelated stale master — rebasing onto the wrong one is silently destructive:

git -C <path> symbolic-ref --quiet --short refs/remotes/origin/HEAD   # e.g. origin/finos-master

Then, on that branch: git -C <path> pull --rebase (not a bare git pull, which errors on divergent branches unless pull.rebase is configured). On any other branch: git -C <path> fetch origin <default>:<default> && git -C <path> rebase <default>.

2. Resync the version pin

legend-engine pins its legend-pure dependency as a fixed pom.xml property (legend.pure.version), so a plain git pull only picks up whatever was last pinned upstream — which lags your local snapshot. Read the actual current version out of your legend-pure checkout's own pom.xml and rewrite legend-engine's pin to match. legend-pure is the root of the chain and pins nothing.

Most root poms here use Maven's CI-friendly <version>${revision}</version> with a <revision> property, so resolve that rather than taking the literal placeholder.

A pin only works if legend-pure is already mvn installed into ~/.m2 — i.e. you built it earlier in this same pass. Otherwise the build fails resolving a SNAPSHOT no repository has.

3. Build

One project at a time. Never two Maven reactor builds at once — this box cannot take it.

cd <path> && mvn -T <threads> clean install -DskipTests

clean install, not plain install: these Pure-source modules fail with IllegalStateException: The code repository <name> already exists! against a stale target/classes.

JDK: JDK 11 for both projects. Don't rely on ambient $JAVA_HOME being right; a non-login shell often has not run the JDK setup.

Resources (tuned for an 8-core/64GB box, one build at a time). Heap goes in the project's .mvn/jvm.config as -Xmx<n>G, or pass MAVEN_OPTS instead to avoid touching a tracked file:

Watch the build to a real BUILD SUCCESS/BUILD FAILURE before starting the next project. If you background it, tail the log — don't infer success from the process exiting.