fork/rules_rust

git clone https://git.julia.blue/fork/rules_rust

wmatthews-googlesupport `resolver = "2"` target-specific features (#1710)84f1d065

rust-analyzer
13.4 KiB315 linesraw
1"""`crates_repository` rule implementation"""
2
3load("//crate_universe/private:common_utils.bzl", "get_rust_tools")
4load(
5    "//crate_universe/private:generate_utils.bzl",
6    "CRATES_REPOSITORY_ENVIRON",
7    "determine_repin",
8    "execute_generator",
9    "generate_config",
10    "get_generator",
11    "get_lockfiles",
12)
13load(
14    "//crate_universe/private:splicing_utils.bzl",
15    "create_splicing_manifest",
16    "splice_workspace_manifest",
17)
18load("//crate_universe/private:urls.bzl", "CARGO_BAZEL_SHA256S", "CARGO_BAZEL_URLS")
19load("//rust:defs.bzl", "rust_common")
20load("//rust/platform:triple.bzl", "get_host_triple")
21load("//rust/platform:triple_mappings.bzl", "SUPPORTED_PLATFORM_TRIPLES")
22
23def _crates_repository_impl(repository_ctx):
24    # Determine the current host's platform triple
25    host_triple = get_host_triple(repository_ctx)
26
27    # Locate the generator to use
28    generator, generator_sha256 = get_generator(repository_ctx, host_triple.str)
29
30    # Generate a config file for all settings
31    config_path = generate_config(repository_ctx)
32
33    # Locate the lockfiles
34    lockfiles = get_lockfiles(repository_ctx)
35
36    # Locate Rust tools (cargo, rustc)
37    tools = get_rust_tools(repository_ctx, host_triple)
38    cargo_path = repository_ctx.path(tools.cargo)
39    rustc_path = repository_ctx.path(tools.rustc)
40
41    # Create a manifest of all dependency inputs
42    splicing_manifest = create_splicing_manifest(repository_ctx)
43
44    # Determine whether or not to repin depednencies
45    repin = determine_repin(
46        repository_ctx = repository_ctx,
47        generator = generator,
48        lockfile_path = lockfiles.bazel,
49        config = config_path,
50        splicing_manifest = splicing_manifest,
51        cargo = cargo_path,
52        rustc = rustc_path,
53    )
54
55    # If re-pinning is enabled, gather additional inputs for the generator
56    kwargs = dict()
57    if repin:
58        # Generate a top level Cargo workspace and manifest for use in generation
59        metadata_path = splice_workspace_manifest(
60            repository_ctx = repository_ctx,
61            generator = generator,
62            cargo_lockfile = lockfiles.cargo,
63            splicing_manifest = splicing_manifest,
64            config_path = config_path,
65            cargo = cargo_path,
66            rustc = rustc_path,
67        )
68
69        kwargs.update({
70            "metadata": metadata_path,
71        })
72
73    # Run the generator
74    execute_generator(
75        repository_ctx = repository_ctx,
76        generator = generator,
77        config = config_path,
78        splicing_manifest = splicing_manifest,
79        lockfile_path = lockfiles.bazel,
80        cargo_lockfile_path = lockfiles.cargo,
81        repository_dir = repository_ctx.path("."),
82        cargo = cargo_path,
83        rustc = rustc_path,
84        # sysroot = tools.sysroot,
85        **kwargs
86    )
87
88    # Determine the set of reproducible values
89    attrs = {attr: getattr(repository_ctx.attr, attr) for attr in dir(repository_ctx.attr)}
90    exclude = ["to_json", "to_proto"]
91    for attr in exclude:
92        attrs.pop(attr, None)
93
94    # Note that this is only scoped to the current host platform. Users should
95    # ensure they provide all the values necessary for the host environments
96    # they support
97    if generator_sha256:
98        attrs.update({"generator_sha256s": generator_sha256})
99
100    # Inform users that the repository rule can be made deterministic if they
101    # add a label to a lockfile path specifically for Bazel.
102    if not lockfiles.bazel:
103        attrs.update({"lockfile": repository_ctx.attr.cargo_lockfile.relative("cargo-bazel-lock.json")})
104
105    return attrs
106
107crates_repository = repository_rule(
108    doc = """\
109A rule for defining and downloading Rust dependencies (crates). This rule
110handles all the same [workflows](#workflows) `crate_universe` rules do.
111
112Environment Variables:
113
114| variable | usage |
115| --- | --- |
116| `CARGO_BAZEL_GENERATOR_SHA256` | The sha256 checksum of the file located at `CARGO_BAZEL_GENERATOR_URL` |
117| `CARGO_BAZEL_GENERATOR_URL` | The URL of a cargo-bazel binary. This variable takes precedence over attributes and can use `file://` for local paths |
118| `CARGO_BAZEL_ISOLATED` | An authorative flag as to whether or not the `CARGO_HOME` environment variable should be isolated from the host configuration |
119| `CARGO_BAZEL_REPIN` | An indicator that the dependencies represented by the rule should be regenerated. `REPIN` may also be used. See [Repinning / Updating Dependencies](#crates_repository_repinning_updating_dependencies) for more details. |
120| `CARGO_BAZEL_REPIN_ONLY` | A comma-delimited allowlist for rules to execute repinning. Can be useful if multiple instances of the repository rule are used in a Bazel workspace, but repinning should be limited to one of them. |
121
122Example:
123
124Given the following workspace structure:
125
126```text
127[workspace]/
128    WORKSPACE
129    BUILD
130    Cargo.toml
131    Cargo.Bazel.lock
132    src/
133        main.rs
134```
135
136The following is something that'd be found in the `WORKSPACE` file:
137
138```python
139load("@rules_rust//crate_universe:defs.bzl", "crates_repository", "crate")
140
141crates_repository(
142    name = "crate_index",
143    annotations = {
144        "rand": [crate.annotation(
145            default_features = False,
146            features = ["small_rng"],
147        )],
148    },
149    cargo_lockfile = "//:Cargo.Bazel.lock",
150    lockfile = "//:cargo-bazel-lock.json",
151    manifests = ["//:Cargo.toml"],
152    # Should match the version represented by the currently registered `rust_toolchain`.
153    rust_version = "1.60.0",
154)
155```
156
157The above will create an external repository which contains aliases and macros for accessing
158Rust targets found in the dependency graph defined by the given manifests.
159
160**NOTE**: The `cargo_lockfile` and `lockfile` must be manually created. The rule unfortunately does not yet create
161it on its own. When initially setting up this rule, an empty file should be created and then
162populated by repinning dependencies.
163
164<a id="#crates_repository_repinning_updating_dependencies"></a>
165
166### Repinning / Updating Dependencies
167
168Dependency syncing and updating is done in the repository rule which means it's done during the
169analysis phase of builds. As mentioned in the environments variable table above, the `CARGO_BAZEL_REPIN`
170(or `REPIN`) environment variables can be used to force the rule to update dependencies and potentially
171render a new lockfile. Given an instance of this repository rule named `crate_index`, the easiest way to
172repin dependencies is to run:
173
174```shell
175CARGO_BAZEL_REPIN=1 bazel sync --only=crate_index
176```
177
178This will result in all dependencies being updated for a project. The `CARGO_BAZEL_REPIN` environment variable
179can also be used to customize how dependencies are updated. The following table shows translations from environment
180variable values to the equivilant [cargo update](https://doc.rust-lang.org/cargo/commands/cargo-update.html) command
181that is called behind the scenes to update dependencies.
182
183| Value | Cargo command |
184| --- | --- |
185| Any of [`true`, `1`, `yes`, `on`, `workspace`] | `cargo update --workspace` |
186| Any of [`full`, `eager`, `all`] | `cargo update` |
187| `package_name` | `cargo upgrade --package package_name` |
188| `package_name@1.2.3` | `cargo upgrade --package package_name --precise 1.2.3` |
189
190If the `crates_repository` is used multiple times in the same Bazel workspace (e.g. for multiple independent
191Rust workspaces), it may additionally be useful to use the `CARGO_BAZEL_REPIN_ONLY` environment variable, which
192limits execution of the repinning to one or multiple instances of the `crates_repository` rule via a comma-delimited
193allowlist:
194
195```shell
196CARGO_BAZEL_REPIN=1 CARGO_BAZEL_REPIN_ONLY=crate_index bazel sync --only=crate_index
197```
198
199""",
200    implementation = _crates_repository_impl,
201    attrs = {
202        "annotations": attr.string_list_dict(
203            doc = "Extra settings to apply to crates. See [crate.annotation](#crateannotation).",
204        ),
205        "cargo_config": attr.label(
206            doc = "A [Cargo configuration](https://doc.rust-lang.org/cargo/reference/config.html) file",
207        ),
208        "cargo_lockfile": attr.label(
209            doc = (
210                "The path used to store the `crates_repository` specific " +
211                "[Cargo.lock](https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html) file. " +
212                "In the case that your `crates_repository` corresponds directly with an existing " +
213                "`Cargo.toml` file which has a paired `Cargo.lock` file, that `Cargo.lock` file " +
214                "should be used here, which will keep the versions used by cargo and bazel in sync."
215            ),
216            mandatory = True,
217        ),
218        "generate_binaries": attr.bool(
219            doc = (
220                "Whether to generate `rust_binary` targets for all the binary crates in every package. " +
221                "By default only the `rust_library` targets are generated."
222            ),
223            default = False,
224        ),
225        "generate_build_scripts": attr.bool(
226            doc = (
227                "Whether or not to generate " +
228                "[cargo build scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html) by default."
229            ),
230            default = True,
231        ),
232        "generator": attr.string(
233            doc = (
234                "The absolute label of a generator. Eg. `@cargo_bazel_bootstrap//:cargo-bazel`. " +
235                "This is typically used when bootstrapping"
236            ),
237        ),
238        "generator_sha256s": attr.string_dict(
239            doc = "Dictionary of `host_triple` -> `sha256` for a `cargo-bazel` binary.",
240            default = CARGO_BAZEL_SHA256S,
241        ),
242        "generator_urls": attr.string_dict(
243            doc = (
244                "URL template from which to download the `cargo-bazel` binary. `{host_triple}` and will be " +
245                "filled in according to the host platform."
246            ),
247            default = CARGO_BAZEL_URLS,
248        ),
249        "isolated": attr.bool(
250            doc = (
251                "If true, `CARGO_HOME` will be overwritten to a directory within the generated repository in " +
252                "order to prevent other uses of Cargo from impacting having any effect on the generated targets " +
253                "produced by this rule. For users who either have multiple `crate_repository` definitions in a " +
254                "WORKSPACE or rapidly re-pin dependencies, setting this to false may improve build times. This " +
255                "variable is also controled by `CARGO_BAZEL_ISOLATED` environment variable."
256            ),
257            default = True,
258        ),
259        "lockfile": attr.label(
260            doc = (
261                "The path to a file to use for reproducible renderings. " +
262                "If set, this file must exist within the workspace (but can be empty) before this rule will work."
263            ),
264        ),
265        "manifests": attr.label_list(
266            doc = "A list of Cargo manifests (`Cargo.toml` files).",
267        ),
268        "packages": attr.string_dict(
269            doc = "A set of crates (packages) specifications to depend on. See [crate.spec](#crate.spec).",
270        ),
271        "quiet": attr.bool(
272            doc = "If stdout and stderr should not be printed to the terminal.",
273            default = True,
274        ),
275        "render_config": attr.string(
276            doc = (
277                "The configuration flags to use for rendering. Use `//crate_universe:defs.bzl\\%render_config` to " +
278                "generate the value for this field. If unset, the defaults defined there will be used."
279            ),
280        ),
281        "rust_toolchain_cargo_template": attr.string(
282            doc = (
283                "The template to use for finding the host `cargo` binary. `{version}` (eg. '1.53.0'), " +
284                "`{triple}` (eg. 'x86_64-unknown-linux-gnu'), `{arch}` (eg. 'aarch64'), `{vendor}` (eg. 'unknown'), " +
285                "`{system}` (eg. 'darwin'), `{cfg}` (eg. 'exec'), `{channel}` (eg. 'stable'), and `{tool}` (eg. " +
286                "'rustc.exe') will be replaced in the string if present."
287            ),
288            default = "@rust_{system}_{arch}__{triple}__{channel}_tools//:bin/{tool}",
289        ),
290        "rust_toolchain_rustc_template": attr.string(
291            doc = (
292                "The template to use for finding the host `rustc` binary. `{version}` (eg. '1.53.0'), " +
293                "`{triple}` (eg. 'x86_64-unknown-linux-gnu'), `{arch}` (eg. 'aarch64'), `{vendor}` (eg. 'unknown'), " +
294                "`{system}` (eg. 'darwin'), `{cfg}` (eg. 'exec'), `{channel}` (eg. 'stable'), and `{tool}` (eg. " +
295                "'cargo.exe') will be replaced in the string if present."
296            ),
297            default = "@rust_{system}_{arch}__{triple}__{channel}_tools//:bin/{tool}",
298        ),
299        "rust_version": attr.string(
300            doc = "The version of Rust the currently registered toolchain is using. Eg. `1.56.0`, or `nightly/2021-09-08`",
301            default = rust_common.default_version,
302        ),
303        "splicing_config": attr.string(
304            doc = (
305                "The configuration flags to use for splicing Cargo maniests. Use `//crate_universe:defs.bzl\\%rsplicing_config` to " +
306                "generate the value for this field. If unset, the defaults defined there will be used."
307            ),
308        ),
309        "supported_platform_triples": attr.string_list(
310            doc = "A set of all platform triples to consider when generating dependencies.",
311            default = SUPPORTED_PLATFORM_TRIPLES,
312        ),
313    },
314    environ = CRATES_REPOSITORY_ENVIRON,
315)