Bazel技术问询：如何获取目标所有传递源并打包传递配置文件

Got it, let's work through this step by step—Bazel aspects are exactly the right tool here, and once you see how they traverse dependencies, it'll click. The key idea is to use an aspect to crawl through all the relevant attributes (deps, runtime_deps, tars, etc.) of your executable targets, collect every *.foo file along the way, then use a separate rule to bundle those files into a ZIP.

Step 1: Define the Aspect to Collect *.foo Files #

First, we'll create an aspect that traverses your target's dependency chain and snags all *.foo files, whether they're in a target's own srcs or buried in a dependency's attributes.

def _collect_foo_files_aspect_impl(target, ctx):
    # Start with files directly in the current target's srcs (if it has them)
    foo_files = []
    if hasattr(ctx.rule.attr, "srcs"):
        # Filter srcs to only include *.foo files
        foo_files.extend([f for f in ctx.rule.attr.srcs if f.path.endswith(".foo")])
    
    # Traverse all relevant dependency attributes to collect transitive files
    for attr_name in ["deps", "runtime_deps", "tars"]:
        if hasattr(ctx.rule.attr, attr_name):
            for dep in getattr(ctx.rule.attr, attr_name):
                # If the dependency has our collected foo files, add them to the list
                if hasattr(dep, "foo_files"):
                    foo_files.extend(dep.foo_files)
    
    # Return the collected files as a struct provider so other rules can use them
    return [struct(foo_files = depset(foo_files))]

collect_foo_files_aspect = aspect(
    implementation = _collect_foo_files_aspect_impl,
    # Tell Bazel which attributes to traverse with this aspect
    attr_aspects = ["deps", "runtime_deps", "tars"],
)

What this does: #

• The aspect checks each target's srcs for *.foo files first.
• It then walks through the deps, runtime_deps, and tars attributes (add more if your custom rules use other dependency attributes!) to collect files from dependencies.
• We use a depset to avoid duplicate files and handle large dependency trees efficiently.

Step 2: Create a Rule to Bundle Files into a ZIP #

Next, we'll make a rule that applies our aspect to your target, grabs all the collected *.foo files, and packages them into a ZIP.

def _package_foo_files_impl(ctx):
    # Pull in all the *.foo files collected by the aspect
    all_foo_files = ctx.attr.target[collect_foo_files_aspect].foo_files.to_list()
    
    # Declare the output ZIP file
    zip_output = ctx.actions.declare_file(f"{ctx.label.name}_foo_configs.zip")
    
    # Use Bazel's built-in zip tool to package the files
    ctx.actions.run(
        outputs = [zip_output],
        inputs = all_foo_files,
        executable = "zip",
        arguments = [
            "-r", zip_output.path,
        ] + [f.path for f in all_foo_files],
    )
    
    # Return the ZIP as the rule's output
    return [DefaultInfo(files = depset([zip_output]))]

package_foo_configs = rule(
    implementation = _package_foo_files_impl,
    attrs = {
        "target": attr.label(
            mandatory = True,
            aspects = [collect_foo_files_aspect],
            # Allow any executable target type (custom rules, java_binary, container_image)
            allow_files = False,
        ),
    },
)

Step 3: Handle Special Cases (e.g., container_image) #

For targets like container_image, you might need to adjust the aspect to traverse additional attributes. For example, container_image uses layers to include other targets—just add "layers" to the attr_aspects list in the aspect definition:

collect_foo_files_aspect = aspect(
    implementation = _collect_foo_files_aspect_impl,
    attr_aspects = ["deps", "runtime_deps", "tars", "layers"],
)

If your custom rules use unique dependency attributes, just add those to the list too.

Step 4: Usage Example #

Here's how you'd use this with a java_binary and its dependencies:

# Your existing java_binary
java_binary(
    name = "my_service",
    srcs = glob(["src/main/java/**/*.java"]),
    deps = [":my_utils"],
)

# A java_library with a *.foo config file
java_library(
    name = "my_utils",
    srcs = ["src/main/java/Utils.java", "config.foo"],
)

# Package all transitive *.foo files from my_service into a ZIP
package_foo_configs(
    name = "my_service_foo_configs",
    target = ":my_service",
)

Run bazel build :my_service_foo_configs and you'll get a ZIP with all *.foo files from my_service and its dependencies.

Troubleshooting Tips #

• If files are missing: Double-check that the attribute containing those files is listed in attr_aspects (e.g., if your custom rule uses resources, add it to the list).
• For non-standard targets: If a target doesn't expose files via srcs, you might need to pull files from its DefaultInfo.files instead—adjust the aspect's foo_files collection logic to include those.
• Duplicate files: Using depset in the aspect automatically deduplicates files, so you don't have to worry about that.

内容的提问来源于stack exchange，提问作者Ittai