fork/rules_rust

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

UebelAndreDeleted "extra workspace member" functionality from crate_universe (#1406)a15e67d6

0.6.0
11.5 KiB286 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_lockfile",
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 lockfile
34    lockfile = get_lockfile(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 = lockfile.path,
49        lockfile_kind = lockfile.kind,
50        config = config_path,
51        splicing_manifest = splicing_manifest,
52        cargo = cargo_path,
53        rustc = rustc_path,
54    )
55
56    # If re-pinning is enabled, gather additional inputs for the generator
57    kwargs = dict()
58    if repin or lockfile.kind == "cargo":
59        # Generate a top level Cargo workspace and manifest for use in generation
60        metadata_path = splice_workspace_manifest(
61            repository_ctx = repository_ctx,
62            generator = generator,
63            lockfile = lockfile,
64            splicing_manifest = splicing_manifest,
65            cargo = cargo_path,
66            rustc = rustc_path,
67        )
68
69        kwargs.update({
70            "metadata": metadata_path,
71            "repin": True,
72        })
73
74    # Run the generator
75    execute_generator(
76        repository_ctx = repository_ctx,
77        generator = generator,
78        config = config_path,
79        splicing_manifest = splicing_manifest,
80        lockfile_path = lockfile.path,
81        lockfile_kind = lockfile.kind,
82        repository_dir = repository_ctx.path("."),
83        cargo = cargo_path,
84        rustc = rustc_path,
85        # sysroot = tools.sysroot,
86        **kwargs
87    )
88
89    # Determine the set of reproducible values
90    attrs = {attr: getattr(repository_ctx.attr, attr) for attr in dir(repository_ctx.attr)}
91    exclude = ["to_json", "to_proto"]
92    for attr in exclude:
93        attrs.pop(attr, None)
94
95    # Note that this is only scoped to the current host platform. Users should
96    # ensure they provide all the values necessary for the host environments
97    # they support
98    if generator_sha256:
99        attrs.update({"generator_sha256s": generator_sha256})
100
101    return attrs
102
103crates_repository = repository_rule(
104    doc = """\
105A rule for defining and downloading Rust dependencies (crates). This rule
106handles all the same [workflows](#workflows) `crate_universe` rules do.
107
108Environment Variables:
109
110| variable | usage |
111| --- | --- |
112| `CARGO_BAZEL_GENERATOR_SHA256` | The sha256 checksum of the file located at `CARGO_BAZEL_GENERATOR_URL` |
113| `CARGO_BAZEL_GENERATOR_URL` | The URL of a cargo-bazel binary. This variable takes precedence over attributes and can use `file://` for local paths |
114| `CARGO_BAZEL_ISOLATED` | An authorative flag as to whether or not the `CARGO_HOME` environment variable should be isolated from the host configuration |
115| `CARGO_BAZEL_REPIN` | An indicator that the dependencies represented by the rule should be regenerated. `REPIN` may also be used. |
116
117Example:
118
119Given the following workspace structure:
120```
121[workspace]/
122    WORKSPACE
123    BUILD
124    Cargo.toml
125    Cargo.Bazel.lock
126    src/
127        main.rs
128```
129
130The following is something that'd be found in the `WORKSPACE` file:
131
132```python
133load("@rules_rust//crate_universe:defs.bzl", "crates_repository", "crate")
134
135crates_repository(
136    name = "crate_index",
137    annotations = annotations = {
138        "rand": [crate.annotation(
139            default_features = False,
140            features = ["small_rng"],
141        )],
142    },
143    lockfile = "//:Cargo.Bazel.lock",
144    manifests = ["//:Cargo.toml"],
145    # Should match the version represented by the currently registered `rust_toolchain`.
146    rust_version = "1.60.0",
147)
148```
149
150The above will create an external repository which contains aliases and macros for accessing
151Rust targets found in the dependency graph defined by the given manifests.
152
153**NOTE**: The `lockfile` must be manually created. The rule unfortunately does not yet create
154it on its own. When initially setting up this rule, an empty file should be created and then
155populated by repinning dependencies.
156
157### Repinning / Updating Dependencies
158
159Dependency syncing and updating is done in the repository rule which means it's done during the
160analysis phase of builds. As mentioned in the environments variable table above, the `CARGO_BAZEL_REPIN`
161(or `REPIN`) environment variables can be used to force the rule to update dependencies and potentially
162render a new lockfile. Given an instance of this repository rule named `crate_index`, the easiest way to
163repin dependencies is to run:
164
165```shell
166CARGO_BAZEL_REPIN=1 bazel sync --only=crate_index
167```
168
169""",
170    implementation = _crates_repository_impl,
171    attrs = {
172        "annotations": attr.string_list_dict(
173            doc = "Extra settings to apply to crates. See [crate.annotation](#crateannotation).",
174        ),
175        "cargo_config": attr.label(
176            doc = "A [Cargo configuration](https://doc.rust-lang.org/cargo/reference/config.html) file",
177        ),
178        "generate_build_scripts": attr.bool(
179            doc = (
180                "Whether or not to generate " +
181                "[cargo build scripts](https://doc.rust-lang.org/cargo/reference/build-scripts.html) by default."
182            ),
183            default = True,
184        ),
185        "generator": attr.string(
186            doc = (
187                "The absolute label of a generator. Eg. `@cargo_bazel_bootstrap//:cargo-bazel`. " +
188                "This is typically used when bootstrapping"
189            ),
190        ),
191        "generator_sha256s": attr.string_dict(
192            doc = "Dictionary of `host_triple` -> `sha256` for a `cargo-bazel` binary.",
193            default = CARGO_BAZEL_SHA256S,
194        ),
195        "generator_urls": attr.string_dict(
196            doc = (
197                "URL template from which to download the `cargo-bazel` binary. `{host_triple}` and will be " +
198                "filled in according to the host platform."
199            ),
200            default = CARGO_BAZEL_URLS,
201        ),
202        "isolated": attr.bool(
203            doc = (
204                "If true, `CARGO_HOME` will be overwritten to a directory within the generated repository in " +
205                "order to prevent other uses of Cargo from impacting having any effect on the generated targets " +
206                "produced by this rule. For users who either have multiple `crate_repository` definitions in a " +
207                "WORKSPACE or rapidly re-pin dependencies, setting this to false may improve build times. This " +
208                "variable is also controled by `CARGO_BAZEL_ISOLATED` environment variable."
209            ),
210            default = True,
211        ),
212        "lockfile": attr.label(
213            doc = (
214                "The path to a file to use for reproducible renderings. Two kinds of lock files are supported, " +
215                "Cargo (`Cargo.lock` files) and Bazel (custom files generated by this rule, naming is irrelevant). " +
216                "Bazel lockfiles should be the prefered kind as they're desigend with Bazel's notions of " +
217                "reporducibility in mind. Cargo lockfiles can be used in cases where it's intended to be the " +
218                "source of truth, but more work will need to be done to generate BUILD files which are not " +
219                "guaranteed to be determinsitic."
220            ),
221            mandatory = True,
222        ),
223        "lockfile_kind": attr.string(
224            doc = (
225                "Two different kinds of lockfiles are supported, the custom \"Bazel\" lockfile, which is generated " +
226                "by this rule, and Cargo lockfiles (`Cargo.lock`). This attribute allows for explicitly defining " +
227                "the type in cases where it may not be auto-detectable."
228            ),
229            values = [
230                "auto",
231                "bazel",
232                "cargo",
233            ],
234            default = "auto",
235        ),
236        "manifests": attr.label_list(
237            doc = "A list of Cargo manifests (`Cargo.toml` files).",
238        ),
239        "packages": attr.string_dict(
240            doc = "A set of crates (packages) specifications to depend on. See [crate.spec](#crate.spec).",
241        ),
242        "quiet": attr.bool(
243            doc = "If stdout and stderr should not be printed to the terminal.",
244            default = True,
245        ),
246        "render_config": attr.string(
247            doc = (
248                "The configuration flags to use for rendering. Use `//crate_universe:defs.bzl\\%render_config` to " +
249                "generate the value for this field. If unset, the defaults defined there will be used."
250            ),
251        ),
252        "rust_toolchain_cargo_template": attr.string(
253            doc = (
254                "The template to use for finding the host `cargo` binary. `{version}` (eg. '1.53.0'), " +
255                "`{triple}` (eg. 'x86_64-unknown-linux-gnu'), `{arch}` (eg. 'aarch64'), `{vendor}` (eg. 'unknown'), " +
256                "`{system}` (eg. 'darwin'), `{cfg}` (eg. 'exec'), and `{tool}` (eg. 'rustc.exe') will be replaced in " +
257                "the string if present."
258            ),
259            default = "@rust_{system}_{arch}//:bin/{tool}",
260        ),
261        "rust_toolchain_rustc_template": attr.string(
262            doc = (
263                "The template to use for finding the host `rustc` binary. `{version}` (eg. '1.53.0'), " +
264                "`{triple}` (eg. 'x86_64-unknown-linux-gnu'), `{arch}` (eg. 'aarch64'), `{vendor}` (eg. 'unknown'), " +
265                "`{system}` (eg. 'darwin'), `{cfg}` (eg. 'exec'), and `{tool}` (eg. 'cargo.exe') will be replaced in " +
266                "the string if present."
267            ),
268            default = "@rust_{system}_{arch}//:bin/{tool}",
269        ),
270        "rust_version": attr.string(
271            doc = "The version of Rust the currently registered toolchain is using. Eg. `1.56.0`, or `nightly-2021-09-08`",
272            default = rust_common.default_version,
273        ),
274        "splicing_config": attr.string(
275            doc = (
276                "The configuration flags to use for splicing Cargo maniests. Use `//crate_universe:defs.bzl\\%rsplicing_config` to " +
277                "generate the value for this field. If unset, the defaults defined there will be used."
278            ),
279        ),
280        "supported_platform_triples": attr.string_list(
281            doc = "A set of all platform triples to consider when generating dependencies.",
282            default = SUPPORTED_PLATFORM_TRIPLES,
283        ),
284    },
285    environ = CRATES_REPOSITORY_ENVIRON,
286)