Support RunfilesGroupInfo - #368
Open
malt3 wants to merge 1 commit into
Open
Conversation
malt3
force-pushed
the
support_runfiles_groups
branch
2 times, most recently
from
July 24, 2026 16:48
eb1d207 to
a0618f8
Compare
fmeum
reviewed
Jul 24, 2026
fmeum
reviewed
Jul 24, 2026
Author
|
I discussed with @fmeum that it's possible to make this provider a lot more memory efficient. I'll also add a global flag to enable/disable the emition of this provider for memory conscious users. |
malt3
marked this pull request as draft
July 24, 2026 18:38
malt3
force-pushed
the
support_runfiles_groups
branch
from
July 27, 2026 12:09
a0618f8 to
2b9068c
Compare
fmeum
reviewed
Jul 27, 2026
fmeum
approved these changes
Jul 27, 2026
malt3
force-pushed
the
support_runfiles_groups
branch
2 times, most recently
from
July 27, 2026 12:56
f989530 to
705d909
Compare
Author
I will, but it's referencing a prerelease version of EDIT: done. Now pointing at |
malt3
marked this pull request as ready for review
July 27, 2026 14:57
Teach the Java rules to describe their runfiles as named, ordered groups
so that downstream packaging rules can build more efficient artifacts.
`java_binary`, `java_test`, `java_library`, and `java_import` now return
`RunfilesGroupInfo` from the `rules_runfiles_group` ruleset alongside
`DefaultInfo`. Instead of seeing a single flat runfiles tree, a packaging rule
(e.g. a container-image or archive rule) can split a binary's runfiles into
layers and order them so that the content that changes least often lands in the
most cacheable layers:
* the JDK / java_runtime at the foundation tier (never merged),
* `java_import` targets (typically third-party jars) at the shared-deps tier,
* `java_library` code, the binary's own jars, and the executable at the
executable tier, marked `first_party` only for targets in the main
repository -- plenty of Java code Bazel builds from source belongs to
somebody else.
Libraries propagate fine-grained per-target groups up through their dependents
as a depset of group entries, each carrying its own metadata, so what a target
retains does not grow with the size of its closure. The binary collects them,
adds its own groups, and tags every group it produces with the `rules_java`
merge affinity so that JVM-shaped groups stay together when a packager has to
merge groups to fit a layer limit. A dependency that returns `JavaInfo` but no
`RunfilesGroupInfo` -- a custom rule, or `rules_jvm_external`'s `jvm_import` --
gets a synthesized group covering its transitive runtime jars and its default
runfiles, so a packager never silently loses its files. `java_import` gains a
`runfiles_weight` attribute so dependency-management rulesets can hint at
relative sizes to guide those merge decisions.
Emission is off by default and gated on the ruleset-wide
`--@rules_runfiles_group//runfiles_group:enabled` flag, so a build that packages
nothing pays nothing for the providers. Consumers that don't understand
`RunfilesGroupInfo` are unaffected and keep using
`DefaultInfo.default_runfiles`.
Adds a dependency on `rules_runfiles_group` for both Bzlmod and WORKSPACE
setups.
malt3
force-pushed
the
support_runfiles_groups
branch
from
July 27, 2026 17:00
705d909 to
1ad4ccc
Compare
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Teach the Java rules to describe their runfiles as named, ordered groups so that downstream packaging rules can build more efficient artifacts.
java_binary,java_test,java_library, andjava_importnow returnRunfilesGroupInfo(andRunfilesGroupMetadataInfo) from therules_runfiles_groupruleset alongsideDefaultInfo. Instead of seeing a single flat runfiles tree, a packaging rule (e.g. a container-image or archive rule) can split a binary's runfiles into layers and order them so that the content that changes least often lands in the most cacheable layers:java_importtargets (typically third-party jars) at the shared-deps tier,java_librarycode, the binary's own jars, and the executable at the executable tier.Libraries propagate fine-grained per-target groups up through their dependents; the binary collects them, adds its own groups, and tags every group it produces with the
rules_javamerge affinity so that JVM-shaped groups stay together when a packager has to merge groups to fit a layer limit.java_importgains arunfiles_weightattribute so dependency-management rulesets can hint at relative sizes to guide those merge decisions.Consumers that don't understand
RunfilesGroupInfoare unaffected and keep usingDefaultInfo.default_runfiles.Adds a dependency on
rules_runfiles_groupfor both Bzlmod and WORKSPACE setups.Validation
I took the liberty to host a BCR mirror that has support enabled for rules_java and rules_img. I also created a demo repo to show the effect.
This shows two
java_binarytargets with overlapping dependencies. Both are packaged as container images.Without
RunfilesGroupInfo, the wholejava_binaryis stored as a single layer and there is no sharing (only the base image layer is shared):With
RunfilesGroupInfo, individual runfiles fromjava_librarytargets get their own layers and most of the content is shared across the container images: