diff --git a/docs/extension_api.md b/docs/extension_api.md index 5d7ed65..bef9033 100644 --- a/docs/extension_api.md +++ b/docs/extension_api.md @@ -23,7 +23,7 @@ Consumers interact with this repository through the `gcc` module extension in Typical usage looks like this: ```starlark -bazel_dep(name = "score_bazel_cpp_toolchains", version = "0.4.0") +bazel_dep(name = "score_bazel_cpp_toolchains", version = "0.5.4") gcc = use_extension("@score_bazel_cpp_toolchains//extensions:gcc.bzl", "gcc") diff --git a/docs/qnx_integration.md b/docs/qnx_integration.md index fe5aabc..c063651 100644 --- a/docs/qnx_integration.md +++ b/docs/qnx_integration.md @@ -15,20 +15,327 @@ # QNX Integration -## Licensing +## Overview + +This guide covers QNX integration with `score_bazel_cpp_toolchains` and is organized for two audiences: + +- **Maintainers of Bazel modules**: If you want to add QNX support to your module, see [Adding QNX Support to Your Module](#adding-qnx-support-to-your-module). This section includes comprehensive integration steps and technical reference. +- **Users and contributors**: If you're working on a module that already has QNX configured, see [Quick Start: Using QNX](#quick-start-using-qnx). +- **Module maintainers documenting for contributors**: See [Documenting QNX Support](#documenting-qnx-support) for a template of what your users need to know. + +--- + +## Adding QNX Support to Your Module + +This section is for maintainers who want to integrate QNX toolchain support into their Bazel modules. + +### Prerequisites + +Before integrating QNX support, ensure: + +1. **QNX SDP access**: Access to URL for downloading and extracting the QNX Software Development Platform (SDP) from https://www.qnx.com/developers/downloads.html +2. **Valid QNX license**: A QNX license file accessible at a known location (see [Licensing](#licensing) section) +3. **Bazel installed**: Version 8.0 or later +4. **Linux host**: Currently tested on Linux build hosts (macOS and Windows are not supported.) + +### Integration Steps + +#### Step 1: Declare the Toolchain Dependency + +In your module's `MODULE.bazel`: + +```starlark +bazel_dep(name = "score_bazel_cpp_toolchains", version = "0.5.4") + +gcc = use_extension("@score_bazel_cpp_toolchains//extensions:gcc.bzl", "gcc") + +gcc.toolchain( + name = "qnx_toolchain", + target_cpu = "x86_64", # or "aarch64" + target_os = "qnx", + sdp_version = "8.0.0", # match your SDP version but keep in mind proper platform constraint must exist otherwise toolchain resolution will fail. + use_default_package = True, # only if you're using reference integration QNX SDP package provided by QNX for S-CORE. + license_path = "/path/to/your/qnx/license", # default location `/opt/score_qnx/license/licenses` +) + +use_repo(gcc, "qnx_toolchain") +``` + +For other target architectures and SDP versions, adjust `target_cpu` and `sdp_version` accordingly. + +#### Step 2: Add Bazel Configuration + +Create or update `.bazelrc` in your repository root: + +```text +# QNX target configurations +build:x86_64-qnx --platforms=@score_bazel_platforms//:x86_64-qnx-sdp_8.0.0-posix +build:x86_64-qnx --extra_toolchains=@qnx_toolchain//:x86_64-qnx-sdp_8.0.0 +build:x86_64-qnx --sandbox_writable_path=/var/tmp + +build:aarch64-qnx --platforms=@score_bazel_platforms//:aarch64-qnx-sdp_8.0.0-posix +build:aarch64-qnx --extra_toolchains=@qnx_toolchain//:aarch64-qnx-sdp_8.0.0 +build:aarch64-qnx --sandbox_writable_path=/var/tmp +``` + +> NOTE: Configuration variables are just an example, it's not mandatory to use exact configuration variables. + +#### Step 3: Test the Integration + +Create a simple test in your repository root: + +```bash +# Test x86_64-qnx build +bazel build --config=x86_64-qnx //your/target:name + +# Test aarch64-qnx build +bazel build --config=aarch64-qnx //your/target:name +``` + +#### Step 4: Add to CI/CD + +Update your CI/CD pipeline to test QNX configurations: + +```yaml +# Example for GitHub Actions +- name: Build for QNX + run: | + bazel build --config=x86_64-qnx //... + bazel test --config=x86_64-qnx //... +``` + +> NOTE: For running tests, host platform must be QNX or use `--run_under=`. Check Bazel documentation for details. + +### Common Integration Patterns + +**Multi-target Modules**: If your module targets multiple architectures: + +```starlark +gcc.toolchain( + name = "qnx_x86_64", + target_cpu = "x86_64", + target_os = "qnx", + sdp_version = "8.0.0", + use_default_package = True, +) + +gcc.toolchain( + name = "qnx_aarch64", + target_cpu = "aarch64", + target_os = "qnx", + sdp_version = "7.1.0", + use_default_package = True, +) +``` + +--- + +## Reference: Technical Details for QNX Integration + +### Obtaining QNX SDP and Licenses + +#### QNX Software Development Platform (SDP) + +The QNX SDP packages are obtained from the official QNX Software repositories: + +- **QNX Momentics IDE and SDPs**: https://www.qnx.com/developers/downloads.html +- **QNX Documentation Portal**: https://www.qnx.com/developers/docs/ +- **Account Registration**: https://account.qnx.com/ + +QNX SDP packages are typically distributed as `.tar.gz` or `.tar.bz2` archives and +contain the host tools (compiler, linker, archiver) and target libraries/headers. + +#### Licensing + +QNX toolchains require a valid QNX license to execute. + +### SDP Installation Layout + +The `score_bazel_cpp_toolchains` module expects QNX SDP packages to follow the standard +QNX directory structure after extraction. A typical installation looks like: + +``` +/path/to/qnx_sdp_VERSION/ +├── host/ # Host tools and libraries +│ └── linux/ +│ └── x86_64/ +│ ├── usr/ +│ │ ├── bin/ +│ │ │ ├── qcc # QNX C compiler driver +│ │ │ ├── q++ # QNX C++ compiler driver +│ │ │ ├── qcc-clang # Clang-based compiler (SDP 8.x) +│ │ │ ├── {TRIPLE}-ar # Archiver +│ │ │ ├── {TRIPLE}-strip +│ │ │ └── {TRIPLE}-gcov +│ │ └── lib/ +│ └── ... +├── target/ # Target platform libraries and headers +│ └── qnx/ +│ ├── usr/ +│ │ ├── include/ # C and C++ headers +│ │ ├── include/c++/v1/ # C++ standard library headers +│ │ ├── lib/ +│ │ └── ... +│ └── ... +└── ... +``` + +Where `{TRIPLE}` is the target triple, e.g. `aarch64-unknown-nto-qnx7.1.0`. + +The toolchain locates these directories via the `QNX_HOST` and `QNX_TARGET` environment +variables, which are set automatically by the toolchain's `sdp_env` feature. + +### Environment Variables + +The QNX toolchain automatically manages `QNX_HOST` and `QNX_TARGET` through the +`sdp_env` feature and does not require explicit user configuration. + +### Bazel Sandbox and Writable Paths + +QNX toolchains require write access to `/var/tmp` for temporary configuration files +during compilation and linking. This is automatically configured via the toolchain's +`sdp_env` feature, which sets `QNX_CONFIGURATION_EXCLUSIVE=/var/tmp/.qnx`. + +If your Bazel configuration restricts sandbox write paths, ensure that `/var/tmp` +is marked as writable: + +```text +build --sandbox_writable_path=/var/tmp +``` + +### Verification: Testing the QNX Toolchain + +To verify that the QNX toolchain is properly configured and usable, run a minimal +test build: + +#### 1. Create a Test C File + +Create a simple test file `hello_qnx.c`: + +```c +#include + +int main() { + printf("Hello from QNX!\n"); + return 0; +} +``` + +#### 2. Create a BUILD File + +Create a `BUILD` file with a simple target: + +```starlark +cc_binary( + name = "hello_qnx", + srcs = ["hello_qnx.c"], +) +``` + +#### 3. Run the Verification Build + +You can verify the toolchain by building with explicit platform and toolchain selection: + +For **x86_64-qnx**: +```bash +bazel build \ + --platforms=@score_bazel_platforms//:x86_64-qnx-sdp_8.0.0-posix \ + --extra_toolchains=@qnx_toolchain//:x86_64-qnx-sdp_8.0.0 \ + //:hello_qnx +``` + +For **aarch64-qnx**: +```bash +bazel build \ + --platforms=@score_bazel_platforms//:aarch64-qnx-sdp_8.0.0-posix \ + --extra_toolchains=@qnx_toolchain//:aarch64-qnx-sdp_8.0.0 \ + //:hello_qnx +``` + +**Tip:** If you've defined `build:` configs in your `.bazelrc` (as shown in +[Step 2: Add Bazel Configuration](#step-2-add-bazel-configuration)), you can simplify to: +```bash +bazel build --config=x86_64-qnx //:hello_qnx +bazel build --config=aarch64-qnx //:hello_qnx +``` + +#### 4. Verify Build Output + +If the build succeeds, the output binary will be available at: + +``` +bazel-bin/hello_qnx +``` + +You can verify it's a QNX binary using file inspection: -QNX toolchains require access to a valid license setup at execution time. The -repository exposes this through toolchain attributes rather than embedding -license material into the package itself. +```bash +file bazel-bin/hello_qnx +# Should output: ELF 64-bit LSB executable, {x86-64|aarch64}, version 1 (SYSV), dynamically linked, ... +# (architecture depends on your target: x86-64 for x86_64-qnx, aarch64 for aarch64-qnx) +``` + +Or use `qfile` if QNX tools are available: + +```bash +qfile bazel-bin/hello_qnx +``` + +#### 5. Troubleshooting + +- **License not found**: Ensure `QNX_SHARED_LICENSE_FILE` is set and points to a valid license file +- **QNX_HOST/QNX_TARGET not set**: The toolchain's `sdp_env` feature sets these automatically; + if you see errors, verify the SDP package path is correct +- **Permission denied on /var/tmp**: Ensure `--sandbox_writable_path=/var/tmp` is in your `.bazelrc` +- **Compilation fails with QCC errors**: Verify the QCC compiler binary exists in the expected location + and the SDP package structure is intact + +--- + +## Quick Start: Using QNX + +If your module already has QNX support configured, follow these minimal steps to build for QNX. + +### Prerequisites + +1. **Access to QNX SDP package**: Your module downloads the SDP package automatically; you just need network access to the QNX repository +2. **Valid QNX license**: Ensure the license file is accessible at `/opt/score_qnx/license/licenses` (or a custom path configured for your module) +3. **Bazel installed**: Version 8.0 or later + +> NOTE: Access to QNX repository is only needed in case you're using reference integration QNX SDP. In case of enterprise package please contact your QNX representative. -Relevant `gcc.toolchain(...)` attributes are: +### Building for QNX -- `license_path` -- `license_info_variable` -- `license_info_url` +Once your module has QNX configured (see your module's documentation for setup), build with: -The default shared license path is `/opt/score_qnx/license/licenses`. This has been -agreed with all module owners and platform developers. +```bash +# For x86_64 target +bazel build --config=x86_64-qnx //... + +# For aarch64 target +bazel build --config=aarch64-qnx //... +``` + +### Running Tests + +Tests can only run on a QNX platform or with `--run_under=`. For builds only: + +```bash +# Build only (no test execution on non-QNX hosts) +bazel build --config=x86_64-qnx //... +``` + +### Troubleshooting + +| Issue | Solution | +|-------|----------| +| Build fails with license errors | Check that QNX license is at `/opt/score_qnx/license/licenses` or ask your module maintainer for license configuration | +| Bazel fails to download SDP | Verify you have network access to https://www.qnx.com and check if credentials are configured (see your module's documentation) | +| Permission denied on `/var/tmp` | This is typically auto-configured; if you see errors, check your module's `.bazelrc` setup | + +For detailed information about the toolchain, see [Reference: Technical Details](#reference-technical-details-for-qnx-integration). + +--- ## Credential Helper @@ -50,4 +357,184 @@ common --credential_helper=*.qnx.com=%workspace%/path/to/qnx_credential_helper.p The helper reads credentials in this order: - `SCORE_QNX_USER` and `SCORE_QNX_PASSWORD` -- `~/.netrc` entry for `qnx.com` \ No newline at end of file +- `~/.netrc` entry for `qnx.com` + +--- + +## Licensing + +QNX toolchains require a valid license to execute at build time. This section covers +all license-related configuration options. + +### Obtaining a QNX License + +- If you don't have a QNX license, obtain one from **QNX Licensing Portal**: https://www.qnx.com/ +- If you want to use QNX free community license **QNX Everywhere**: https://www.qnx.com/developers/docs/qnxeverywhere/index.html + +### License File Location + +QNX licenses are typically installed as a file accessible on the build machine. The +default shared license path expected by the module is: + +``` +/opt/score_qnx/license/licenses +``` + +This path has been agreed upon with all module owners and platform developers. + +### Configuring the License Path + +You can configure the license path in multiple ways, in order of precedence: + +#### 1. Environment Variable (Runtime) + +The generated toolchain sets `QNX_SHARED_LICENSE_FILE` for compile/link actions, based on the `license_path` toolchain attribute. +If you need to use the vendor-provided `QNXLM_LICENSE_FILE` mechanism instead, set it in your shell `export QNXLM_LICENSE_FILE=/path/to/your/license/file` or ensure it is provided to Bazel actions (e.g. via `--action_env=QNXLM_LICENSE_FILE=...`; when `--incompatible_strict_action_env` is enabled, exporting it in your shell alone is not sufficient). + +This is useful when the license is not installed in the default location. + +#### 2. Bazel Configuration (Workspace-wide) + +In your `.bazelrc`: + +```text +build --action_env=QNXLM_LICENSE_FILE=/path/to/your/license/file +``` + +#### 3. Toolchain Attributes (Per-toolchain) + +In your `MODULE.bazel`, pass license configuration to the toolchain: + +```starlark +gcc.toolchain( + name = "qnx_toolchain", + target_cpu = "x86_64", + target_os = "qnx", + sdp_version = "8.0.0", + use_default_package = True, + license_path = "/path/to/your/license/file", +) +``` + +### Custom License Configuration + +For scenarios where the default license path or environment setup is insufficient, +you can configure the license URL: + +```starlark +gcc.toolchain( + name = "qnx_toolchain", + target_cpu = "x86_64", + target_os = "qnx", + sdp_version = "8.0.0", + use_default_package = True, + license_path = "/path/to/your/license/file", + license_info_url = "https://your-license-server.com/qnx-license", +) +``` + +The relevant `gcc.toolchain(...)` attributes for license configuration are: + +- **`license_path`**: Path to the QNX license file directory + (default: `/opt/score_qnx/license/licenses`) +- **`license_info_variable`**: Custom environment variable name for license configuration +- **`license_info_url`**: URL for license server or remote license resource + +--- + +## Documenting QNX Support + +This section is for module maintainers who want to document QNX support for their contributors. + +### Why This Matters + +When your module has QNX support integrated, contributors cloning your repository need clear instructions on how to: +- Set up their local environment +- Run builds and tests for QNX targets +- Troubleshoot common issues + +This guide provides a template you can adapt and include in your module's documentation. + +### Recommended Documentation Template + +Create a file in your repository (e.g., `docs/QNX_SETUP.md` or add to `CONTRIBUTING.md`) with the following content, customized for your module: + +--- + +#### **QNX Setup for Contributors** + +This module supports building for QNX targets. Follow these steps to set up your environment. + +##### Prerequisites + +1. **Access to QNX SDP** + - Verify that you have access to QNX SDP. + - Extract the content for verification. + +2. **Obtain QNX License** + - Request from: https://www.qnx.com/company/contact-us/ (or contact your Project Lead) + - Store the license file at: `/opt/score_qnx/license/licenses` (or configure custom path) + +3. **Install Bazel** + - Version 8.0 or later + - Visit: https://bazel.build/install + +##### Building for QNX + +Build for your target architecture: + +```bash +# x86_64-qnx +bazel build --config=x86_64-qnx //... + +# aarch64-qnx +bazel build --config=aarch64-qnx //... +``` + +##### Running Tests for QNX (on QNX platform) + +```bash +# x86_64-qnx +bazel test --config=x86_64-qnx //... + +# aarch64-qnx +bazel test --config=aarch64-qnx //... +``` + +##### Troubleshooting + +| Issue | Solution | +|-------|----------| +| `License not found` | Verify `QNX_SHARED_LICENSE_FILE` points to valid license file, or check default path `/opt/score_qnx/license/licenses` | +| `QNX_HOST/QNX_TARGET not set` | Ensure SDP is properly extracted; the toolchain sets these automatically if the path is correct | +| `Permission denied on /var/tmp` | Ensure `--sandbox_writable_path=/var/tmp` is in `.bazelrc` or `.bazelrc.local` | +| `qcc: command not found` | Verify QNX_HOST points to the correct host tools directory within your SDP | + +--- + +### Customization Checklist + +When adapting the template above for your module, consider: + +- [ ] **Replace SDP version**: Update `8.0.0` to your module's target SDP version +- [ ] **Update paths**: Adapt default paths and examples to your environment conventions +- [ ] **Update configuration variables**: Adapt configuration variables to your moodule configurations +- [ ] **Add module-specific targets**: Include examples of building your actual targets, not just generic `//...` +- [ ] **CI/CD documentation**: Document how QNX is tested in your CI pipeline (GitHub Actions, GitLab CI, etc.) +- [ ] **Known limitations**: Note any features not yet supported on QNX +- [ ] **Additional resources**: Link to your module's main README, contribution guidelines, etc. +- [ ] **License details**: If your module requires special license setup, document it here +- [ ] **Contact information**: Provide a way for contributors to ask questions (GitHub issues, Slack channel, etc.) + +### Integration into Your Repository + +**Option 1: Separate documentation file** +Create `docs/QNX_SETUP.md` with detailed QNX setup instructions. + +**Option 2: Embedded in CONTRIBUTING.md** +Add a "QNX Setup" section to your existing contribution guidelines. + +**Option 3: Embedded in README.md** +Add a brief section with a link to more detailed QNX documentation elsewhere. + +**Recommendation**: Start with Option 1 (separate file) for clarity, then reference it from `CONTRIBUTING.md` or `README.md`. \ No newline at end of file diff --git a/tests/MODULE.bazel b/tests/MODULE.bazel index 05bfc17..ec41818 100644 --- a/tests/MODULE.bazel +++ b/tests/MODULE.bazel @@ -38,7 +38,7 @@ bazel_dep(name = "googletest", version = "1.17.0") # ******************************************************************************* bazel_dep( name = "score_bazel_cpp_toolchains", - version = "0.4.0", + version = "0.5.4", ) local_path_override( module_name = "score_bazel_cpp_toolchains", diff --git a/tests/MODULE.bazel.lock b/tests/MODULE.bazel.lock index 2c8d513..8184bb4 100644 --- a/tests/MODULE.bazel.lock +++ b/tests/MODULE.bazel.lock @@ -563,6 +563,104 @@ }, "selectedYankedVersions": {}, "moduleExtensions": { + "@@aspect_rules_js+//npm:extensions.bzl%pnpm": { + "general": { + "bzlTransitiveDigest": "z9R57PYt8T9Wu/2SwhxlaNxEusUyr3WsInkutJ8hufU=", + "usagesDigest": "ZYGEy1FrDUNPBzAzD+ujlHkMEsVPMYOvpHm9RhUexUE=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "pnpm": { + "repoRuleId": "@@aspect_rules_js+//npm/private:npm_import.bzl%npm_import_rule", + "attributes": { + "package": "pnpm", + "version": "8.6.7", + "root_package": "", + "link_workspace": "", + "link_packages": {}, + "integrity": "sha512-vRIWpD/L4phf9Bk2o/O2TDR8fFoJnpYrp2TKqTIZF/qZ2/rgL3qKXzHofHgbXsinwMoSEigz28sqk3pQ+yMEQQ==", + "url": "", + "commit": "", + "patch_args": [ + "-p0" + ], + "patches": [], + "custom_postinstall": "", + "npm_auth": "", + "npm_auth_basic": "", + "npm_auth_username": "", + "npm_auth_password": "", + "lifecycle_hooks": [], + "extra_build_content": "load(\"@aspect_rules_js//js:defs.bzl\", \"js_binary\")\njs_binary(name = \"pnpm\", data = glob([\"package/**\"]), entry_point = \"package/dist/pnpm.cjs\", visibility = [\"//visibility:public\"])", + "generate_bzl_library_targets": false, + "extract_full_archive": true + } + }, + "pnpm__links": { + "repoRuleId": "@@aspect_rules_js+//npm/private:npm_import.bzl%npm_import_links", + "attributes": { + "package": "pnpm", + "version": "8.6.7", + "dev": false, + "root_package": "", + "link_packages": {}, + "deps": {}, + "transitive_closure": {}, + "lifecycle_build_target": false, + "lifecycle_hooks_env": [], + "lifecycle_hooks_execution_requirements": [ + "no-sandbox" + ], + "lifecycle_hooks_use_default_shell_env": false, + "bins": {}, + "npm_translate_lock_repo": "", + "package_visibility": [ + "//visibility:public" + ], + "replace_package": "" + } + } + }, + "recordedRepoMappingEntries": [ + [ + "aspect_bazel_lib+", + "bazel_skylib", + "bazel_skylib+" + ], + [ + "aspect_bazel_lib+", + "bazel_tools", + "bazel_tools" + ], + [ + "aspect_rules_js+", + "aspect_bazel_lib", + "aspect_bazel_lib+" + ], + [ + "aspect_rules_js+", + "bazel_features", + "bazel_features+" + ], + [ + "aspect_rules_js+", + "bazel_skylib", + "bazel_skylib+" + ], + [ + "aspect_rules_js+", + "bazel_tools", + "bazel_tools" + ], + [ + "bazel_features+", + "bazel_tools", + "bazel_tools" + ] + ] + } + }, "@@aspect_rules_py+//py:extensions.bzl%py_tools": { "general": { "bzlTransitiveDigest": "/auhlg7ATdFttD+/XpCyzxusSYn4Pc9zPT+ABAWFEDw=", @@ -705,6 +803,464 @@ ] } }, + "@@gazelle+//:extensions.bzl%go_deps": { + "general": { + "bzlTransitiveDigest": "B5la0IQ0ikF4Rx9OjYZg4KnBflAzCMy0MfsJPxZxXWk=", + "usagesDigest": "tfQCHJg51LFgV7hTP9SLQammcDdAISgPLeV+eH7GlJ4=", + "recordedFileInputs": { + "@@gazelle+//go.mod": "9ae159a385b2f244bbe964b9f91dbea6e7bd534e0b22e846655f241c65de2c49", + "@@gazelle+//go.sum": "7469786f3930030c430969cedae951e6947cb40f4a563dac94a350659c0fedc4", + "@@rules_buf+//go.mod": "c96e5c352880a2df5cd7294265df91c7bad4fb24ef3865ccb1b9ceb29341cf8a", + "@@rules_buf+//go.sum": "968d06e5d35e524686d63dda36b4fb82d5054a4c5a42a5da8214a43cc4e8edb3", + "@@rules_go+//go.mod": "a7143f329c2a3e0b983ce74a96c0c25b0d0c59d236d75f7e1b069aadd988d55e", + "@@rules_go+//go.sum": "022d36c9ebcc7b5dee1e9b85b3da9c9f3a529ee6f979946d66e4955b8d54614a" + }, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "com_github_bazelbuild_buildtools": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/bazelbuild/buildtools", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:2Gc2Q6hVR1SJ8bBI9Ybzoggp8u/ED2WkM4MfvEIn9+c=", + "replace": "", + "version": "v0.0.0-20231115204819-d4c9dccdfbb1" + } + }, + "com_github_stretchr_testify": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/stretchr/testify", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=", + "replace": "", + "version": "v1.8.4" + } + }, + "in_gopkg_yaml_v3": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "gopkg.in/yaml.v3", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=", + "replace": "", + "version": "v3.0.1" + } + }, + "com_github_davecgh_go_spew": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/davecgh/go-spew", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=", + "replace": "", + "version": "v1.1.1" + } + }, + "com_github_google_go_cmp": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/google/go-cmp", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=", + "replace": "", + "version": "v0.6.0" + } + }, + "com_github_pmezard_go_difflib": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/pmezard/go-difflib", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=", + "replace": "", + "version": "v1.0.0" + } + }, + "org_golang_x_mod": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "golang.org/x/mod", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0=", + "replace": "", + "version": "v0.14.0" + } + }, + "org_golang_x_sys": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "golang.org/x/sys", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q=", + "replace": "", + "version": "v0.14.0" + } + }, + "org_golang_x_tools_go_vcs": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "golang.org/x/tools/go/vcs", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:cOIJqWBl99H1dH5LWizPa+0ImeeJq3t3cJjaeOWUAL4=", + "replace": "", + "version": "v0.1.0-deprecated" + } + }, + "in_gopkg_check_v1": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "gopkg.in/check.v1", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=", + "replace": "", + "version": "v1.0.0-20201130134442-10cb98267c6c" + } + }, + "com_github_gogo_protobuf": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/gogo/protobuf", + "build_directives": [ + "gazelle:proto disable" + ], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=", + "replace": "", + "version": "v1.3.2" + } + }, + "com_github_golang_mock": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/golang/mock", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=", + "replace": "", + "version": "v1.6.0" + } + }, + "com_github_golang_protobuf": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/golang/protobuf", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=", + "replace": "", + "version": "v1.5.2" + } + }, + "org_golang_google_protobuf": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "google.golang.org/protobuf", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=", + "replace": "", + "version": "v1.28.0" + } + }, + "org_golang_x_net": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "golang.org/x/net", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:4nGaVu0QrbjT/AK2PRLuQfQuh6DJve+pELhqTdAj3x0=", + "replace": "", + "version": "v0.0.0-20210405180319-a5a99cb37ef4" + } + }, + "org_golang_x_text": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "golang.org/x/text", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=", + "replace": "", + "version": "v0.3.3" + } + }, + "org_golang_google_genproto": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "google.golang.org/genproto", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:+kGHl1aib/qcwaRi1CbqBZ1rk19r85MNUf8HaBghugY=", + "replace": "", + "version": "v0.0.0-20200526211855-cb27e3aa2013" + } + }, + "org_golang_google_grpc": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "google.golang.org/grpc", + "build_directives": [ + "gazelle:proto disable" + ], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:fPVVDxY9w++VjTZsYvXWqEf9Rqar/e+9zYfxKK+W+YU=", + "replace": "", + "version": "v1.50.0" + } + }, + "org_golang_x_tools": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "golang.org/x/tools", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ=", + "replace": "", + "version": "v0.13.0" + } + }, + "com_github_bmatcuk_doublestar_v4": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/bmatcuk/doublestar/v4", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:FH9SifrbvJhnlQpztAx++wlkk70QBf0iBWDwNy7PA4I=", + "replace": "", + "version": "v4.6.1" + } + }, + "com_github_fsnotify_fsnotify": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "github.com/fsnotify/fsnotify", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=", + "replace": "", + "version": "v1.7.0" + } + }, + "org_golang_x_sync": { + "repoRuleId": "@@gazelle+//internal:go_repository.bzl%go_repository", + "attributes": { + "importpath": "golang.org/x/sync", + "build_directives": [], + "build_file_generation": "auto", + "build_extra_args": [], + "patches": [], + "patch_args": [], + "sum": "h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=", + "replace": "", + "version": "v0.4.0" + } + }, + "bazel_gazelle_go_repository_config": { + "repoRuleId": "@@gazelle+//internal/bzlmod:go_deps.bzl%_go_repository_config", + "attributes": { + "importpaths": { + "@gazelle+": "github.com/bazelbuild/bazel-gazelle", + "com_github_bazelbuild_buildtools": "github.com/bazelbuild/buildtools", + "@rules_go+": "github.com/bazelbuild/rules_go", + "com_github_stretchr_testify": "github.com/stretchr/testify", + "in_gopkg_yaml_v3": "gopkg.in/yaml.v3", + "com_github_davecgh_go_spew": "github.com/davecgh/go-spew", + "com_github_google_go_cmp": "github.com/google/go-cmp", + "com_github_pmezard_go_difflib": "github.com/pmezard/go-difflib", + "org_golang_x_mod": "golang.org/x/mod", + "org_golang_x_sys": "golang.org/x/sys", + "org_golang_x_tools_go_vcs": "golang.org/x/tools/go/vcs", + "in_gopkg_check_v1": "gopkg.in/check.v1", + "com_github_gogo_protobuf": "github.com/gogo/protobuf", + "com_github_golang_mock": "github.com/golang/mock", + "com_github_golang_protobuf": "github.com/golang/protobuf", + "org_golang_google_protobuf": "google.golang.org/protobuf", + "org_golang_x_net": "golang.org/x/net", + "org_golang_x_text": "golang.org/x/text", + "org_golang_google_genproto": "google.golang.org/genproto", + "org_golang_google_grpc": "google.golang.org/grpc", + "org_golang_x_tools": "golang.org/x/tools", + "com_github_bmatcuk_doublestar_v4": "github.com/bmatcuk/doublestar/v4", + "com_github_fsnotify_fsnotify": "github.com/fsnotify/fsnotify", + "org_golang_x_sync": "golang.org/x/sync", + "@rules_buf+": "github.com/bufbuild/rules_buf" + }, + "module_names": { + "@rules_buf+": "rules_buf", + "@rules_go+": "rules_go", + "@gazelle+": "gazelle" + }, + "build_naming_conventions": {} + } + } + }, + "moduleExtensionMetadata": { + "explicitRootModuleDirectDeps": [], + "explicitRootModuleDirectDevDeps": [], + "useAllRepos": "NO", + "reproducible": false + }, + "recordedRepoMappingEntries": [ + [ + "gazelle+", + "bazel_tools", + "bazel_tools" + ] + ] + } + }, + "@@gazelle+//internal/bzlmod:non_module_deps.bzl%non_module_deps": { + "general": { + "bzlTransitiveDigest": "AjbsH9WZCj0ipLarbbkp25YBRrRhWYvO7OIiTcHyyok=", + "usagesDigest": "/EIHHLtjAqjZiKFavzwtqyPtUxCp0xuO4NLoiFGXgIw=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "bazel_gazelle_go_repository_cache": { + "repoRuleId": "@@gazelle+//internal:go_repository_cache.bzl%go_repository_cache", + "attributes": { + "go_sdk_name": "@rules_go++go_sdk+go_default_sdk", + "go_env": {} + } + }, + "bazel_gazelle_go_repository_tools": { + "repoRuleId": "@@gazelle+//internal:go_repository_tools.bzl%go_repository_tools", + "attributes": { + "go_cache": "@@gazelle++non_module_deps+bazel_gazelle_go_repository_cache//:go.env" + } + }, + "bazel_gazelle_is_bazel_module": { + "repoRuleId": "@@gazelle+//internal:is_bazel_module.bzl%is_bazel_module", + "attributes": { + "is_bazel_module": true + } + } + }, + "recordedRepoMappingEntries": [ + [ + "gazelle+", + "bazel_gazelle_go_repository_cache", + "gazelle++non_module_deps+bazel_gazelle_go_repository_cache" + ], + [ + "gazelle+", + "go_host_compatible_sdk_label", + "rules_go++go_sdk+go_host_compatible_sdk_label" + ], + [ + "rules_go++go_sdk+go_host_compatible_sdk_label", + "go_default_sdk", + "rules_go++go_sdk+go_default_sdk" + ] + ] + } + }, + "@@pybind11_bazel+//:internal_configure.bzl%internal_configure_extension": { + "general": { + "bzlTransitiveDigest": "vyKH4VZgvJxNRuv2Dn3yUi/i7TcjLFk2up5SgTbIUY8=", + "usagesDigest": "D1r3lfzMuUBFxgG8V6o0bQTLMk3GkaGOaPzw53wrwyw=", + "recordedFileInputs": { + "@@pybind11_bazel+//MODULE.bazel": "e6f4c20442eaa7c90d7190d8dc539d0ab422f95c65a57cc59562170c58ae3d34" + }, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "pybind11": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "build_file": "@@pybind11_bazel+//:pybind11-BUILD.bazel", + "strip_prefix": "pybind11-2.12.0", + "urls": [ + "https://github.com/pybind/pybind11/archive/v2.12.0.zip" + ] + } + } + }, + "recordedRepoMappingEntries": [ + [ + "pybind11_bazel+", + "bazel_tools", + "bazel_tools" + ] + ] + } + }, "@@rules_buf+//buf:extensions.bzl%buf": { "general": { "bzlTransitiveDigest": "sePGRkBYa7vJOQz6tbLoOv/Ni52ygaAUBfoHdxtnwI8=", @@ -730,6 +1286,89 @@ ] } }, + "@@rules_fuzzing+//fuzzing/private:extensions.bzl%non_module_dependencies": { + "general": { + "bzlTransitiveDigest": "lxvzPQyluk241QRYY81nZHOcv5Id/5U2y6dp42qibis=", + "usagesDigest": "wy6ISK6UOcBEjj/mvJ/S3WeXoO67X+1llb9yPyFtPgc=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "platforms": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/0.0.8/platforms-0.0.8.tar.gz", + "https://github.com/bazelbuild/platforms/releases/download/0.0.8/platforms-0.0.8.tar.gz" + ], + "sha256": "8150406605389ececb6da07cbcb509d5637a3ab9a24bc69b1101531367d89d74" + } + }, + "rules_python": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "sha256": "d70cd72a7a4880f0000a6346253414825c19cdd40a28289bdf67b8e6480edff8", + "strip_prefix": "rules_python-0.28.0", + "url": "https://github.com/bazelbuild/rules_python/releases/download/0.28.0/rules_python-0.28.0.tar.gz" + } + }, + "bazel_skylib": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "sha256": "cd55a062e763b9349921f0f5db8c3933288dc8ba4f76dd9416aac68acee3cb94", + "urls": [ + "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz", + "https://github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz" + ] + } + }, + "com_google_absl": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://github.com/abseil/abseil-cpp/archive/refs/tags/20240116.1.zip" + ], + "strip_prefix": "abseil-cpp-20240116.1", + "integrity": "sha256-7capMWOvWyoYbUaHF/b+I2U6XLMaHmky8KugWvfXYuk=" + } + }, + "rules_fuzzing_oss_fuzz": { + "repoRuleId": "@@rules_fuzzing+//fuzzing/private/oss_fuzz:repository.bzl%oss_fuzz_repository", + "attributes": {} + }, + "honggfuzz": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "build_file": "@@rules_fuzzing+//:honggfuzz.BUILD", + "sha256": "6b18ba13bc1f36b7b950c72d80f19ea67fbadc0ac0bb297ec89ad91f2eaa423e", + "url": "https://github.com/google/honggfuzz/archive/2.5.zip", + "strip_prefix": "honggfuzz-2.5" + } + }, + "rules_fuzzing_jazzer": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_jar", + "attributes": { + "sha256": "ee6feb569d88962d59cb59e8a31eb9d007c82683f3ebc64955fd5b96f277eec2", + "url": "https://repo1.maven.org/maven2/com/code-intelligence/jazzer/0.20.1/jazzer-0.20.1.jar" + } + }, + "rules_fuzzing_jazzer_api": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_jar", + "attributes": { + "sha256": "f5a60242bc408f7fa20fccf10d6c5c5ea1fcb3c6f44642fec5af88373ae7aa1b", + "url": "https://repo1.maven.org/maven2/com/code-intelligence/jazzer-api/0.20.1/jazzer-api-0.20.1.jar" + } + } + }, + "recordedRepoMappingEntries": [ + [ + "rules_fuzzing+", + "bazel_tools", + "bazel_tools" + ] + ] + } + }, "@@rules_go+//go:extensions.bzl%go_sdk": { "os:linux,arch:amd64": { "bzlTransitiveDigest": "9JKZqQmIEnLoXxZGppGVismV4hf0L4VZsaTELlXwCUM=", @@ -808,6 +1447,225 @@ ] } }, + "@@rules_go+//go/private:extensions.bzl%non_module_dependencies": { + "general": { + "bzlTransitiveDigest": "Rn55bNn9CiwgGXTm6vfW+2ytVLWzXlgCyCeeAjDMWkU=", + "usagesDigest": "JL1XfI3Chd9vaoVGnIlNXDdHjWcf9WYe/Lu+A1HCC74=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "bazel_skylib": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.4.2/bazel-skylib-1.4.2.tar.gz", + "https://github.com/bazelbuild/bazel-skylib/releases/download/1.4.2/bazel-skylib-1.4.2.tar.gz" + ], + "sha256": "66ffd9315665bfaafc96b52278f57c7e2dd09f5ede279ea6d39b2be471e7e3aa", + "strip_prefix": "" + } + }, + "org_golang_x_tools": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/golang/tools/archive/refs/tags/v0.7.0.zip", + "https://github.com/golang/tools/archive/refs/tags/v0.7.0.zip" + ], + "sha256": "9f20a20f29f4008d797a8be882ef82b69cf8f7f2b96dbdfe3814c57d8280fa4b", + "strip_prefix": "tools-0.7.0", + "patches": [ + "@@rules_go+//third_party:org_golang_x_tools-deletegopls.patch", + "@@rules_go+//third_party:org_golang_x_tools-gazelle.patch" + ], + "patch_args": [ + "-p1" + ] + } + }, + "org_golang_x_tools_go_vcs": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/golang/tools/archive/refs/tags/go/vcs/v0.1.0-deprecated.zip", + "https://github.com/golang/tools/archive/refs/tags/go/vcs/v0.1.0-deprecated.zip" + ], + "sha256": "1b389268d126467105305ae4482df0189cc80a13aaab28d0946192b4ad0737a8", + "strip_prefix": "tools-go-vcs-v0.1.0-deprecated/go/vcs", + "patches": [ + "@@rules_go+//third_party:org_golang_x_tools_go_vcs-gazelle.patch" + ], + "patch_args": [ + "-p1" + ] + } + }, + "org_golang_x_sys": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/golang/sys/archive/refs/tags/v0.12.0.zip", + "https://github.com/golang/sys/archive/refs/tags/v0.12.0.zip" + ], + "sha256": "229b079d23d18f5b1a0c46335020cddc6e5d543da2dae6e45b59d84b5d074e3a", + "strip_prefix": "sys-0.12.0", + "patches": [ + "@@rules_go+//third_party:org_golang_x_sys-gazelle.patch" + ], + "patch_args": [ + "-p1" + ] + } + }, + "org_golang_x_xerrors": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/golang/xerrors/archive/04be3eba64a22a838cdb17b8dca15a52871c08b4.zip", + "https://github.com/golang/xerrors/archive/04be3eba64a22a838cdb17b8dca15a52871c08b4.zip" + ], + "sha256": "ffad2b06ef2e09d040da2ff08077865e99ab95d4d0451737fc8e33706bb01634", + "strip_prefix": "xerrors-04be3eba64a22a838cdb17b8dca15a52871c08b4", + "patches": [ + "@@rules_go+//third_party:org_golang_x_xerrors-gazelle.patch" + ], + "patch_args": [ + "-p1" + ] + } + }, + "org_golang_google_protobuf": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "sha256": "f5d1f6d0e9b836aceb715f1df2dc065083a55b07ecec3b01b5e89d039b14da02", + "urls": [ + "https://mirror.bazel.build/github.com/protocolbuffers/protobuf-go/archive/refs/tags/v1.31.0.zip", + "https://github.com/protocolbuffers/protobuf-go/archive/refs/tags/v1.31.0.zip" + ], + "strip_prefix": "protobuf-go-1.31.0", + "patches": [ + "@@rules_go+//third_party:org_golang_google_protobuf-gazelle.patch" + ], + "patch_args": [ + "-p1" + ] + } + }, + "com_github_golang_protobuf": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/golang/protobuf/archive/refs/tags/v1.5.3.zip", + "https://github.com/golang/protobuf/archive/refs/tags/v1.5.3.zip" + ], + "sha256": "2dced4544ae5372281e20f1e48ca76368355a01b31353724718c4d6e3dcbb430", + "strip_prefix": "protobuf-1.5.3", + "patches": [ + "@@rules_go+//third_party:com_github_golang_protobuf-gazelle.patch" + ], + "patch_args": [ + "-p1" + ] + } + }, + "com_github_mwitkow_go_proto_validators": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/mwitkow/go-proto-validators/archive/refs/tags/v0.3.2.zip", + "https://github.com/mwitkow/go-proto-validators/archive/refs/tags/v0.3.2.zip" + ], + "sha256": "d8697f05a2f0eaeb65261b480e1e6035301892d9fc07ed945622f41b12a68142", + "strip_prefix": "go-proto-validators-0.3.2" + } + }, + "com_github_gogo_protobuf": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/gogo/protobuf/archive/refs/tags/v1.3.2.zip", + "https://github.com/gogo/protobuf/archive/refs/tags/v1.3.2.zip" + ], + "sha256": "f89f8241af909ce3226562d135c25b28e656ae173337b3e58ede917aa26e1e3c", + "strip_prefix": "protobuf-1.3.2", + "patches": [ + "@@rules_go+//third_party:com_github_gogo_protobuf-gazelle.patch" + ], + "patch_args": [ + "-p1" + ] + } + }, + "gogo_special_proto": { + "repoRuleId": "@@rules_go+//proto:gogo.bzl%gogo_special_proto", + "attributes": {} + }, + "org_golang_google_genproto": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/googleapis/go-genproto/archive/007df8e322eb3e384d36c0821e2337825c203ca6.zip", + "https://github.com/googleapis/go-genproto/archive/007df8e322eb3e384d36c0821e2337825c203ca6.zip" + ], + "sha256": "e7d0f3faed86258ed4e8e5527a8e98ff00fbd5b1a9b379a99a4aa2f76ce8bbcc", + "strip_prefix": "go-genproto-007df8e322eb3e384d36c0821e2337825c203ca6", + "patches": [ + "@@rules_go+//third_party:org_golang_google_genproto-gazelle.patch" + ], + "patch_args": [ + "-p1" + ] + } + }, + "com_github_golang_mock": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/golang/mock/archive/refs/tags/v1.7.0-rc.1.zip", + "https://github.com/golang/mock/archive/refs/tags/v1.7.0-rc.1.zip" + ], + "patches": [ + "@@rules_go+//third_party:com_github_golang_mock-gazelle.patch" + ], + "patch_args": [ + "-p1" + ], + "sha256": "5359c78b0c1649cf7beb3b48ff8b1d1aaf0243b22ea4789aba94805280075d8e", + "strip_prefix": "mock-1.7.0-rc.1" + } + }, + "io_bazel_rules_nogo": { + "repoRuleId": "@@rules_go+//go/private:nogo.bzl%go_register_nogo", + "attributes": { + "nogo": "@io_bazel_rules_go//:default_nogo" + } + } + }, + "recordedRepoMappingEntries": [ + [ + "bazel_features+", + "bazel_features_globals", + "bazel_features++version_extension+bazel_features_globals" + ], + [ + "bazel_features+", + "bazel_features_version", + "bazel_features++version_extension+bazel_features_version" + ], + [ + "rules_go+", + "bazel_features", + "bazel_features+" + ], + [ + "rules_go+", + "bazel_tools", + "bazel_tools" + ] + ] + } + }, "@@rules_kotlin+//src/main/starlark/core/repositories:bzlmod_setup.bzl%rules_kotlin_extensions": { "general": { "bzlTransitiveDigest": "hUTp2w+RUVdL7ma5esCXZJAFnX7vLbVfLd7FwnQI6bU=", @@ -1042,6 +1900,158 @@ ] } }, + "@@rules_rust+//crate_universe/private:internal_extensions.bzl%cu_nr": { + "general": { + "bzlTransitiveDigest": "gVtgT7glGR1T+ubbYuYNuRDSxAQJ4d86ZafxsQchHhQ=", + "usagesDigest": "dQ7SQZ7uSSL3vVKSMBKRxKJUm9OVrZZA+S1/QQfT570=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "cargo_bazel_bootstrap": { + "repoRuleId": "@@rules_rust+//cargo/private:cargo_bootstrap.bzl%cargo_bootstrap_repository", + "attributes": { + "srcs": [ + "@@rules_rust+//crate_universe:src/api.rs", + "@@rules_rust+//crate_universe:src/api/lockfile.rs", + "@@rules_rust+//crate_universe:src/cli.rs", + "@@rules_rust+//crate_universe:src/cli/generate.rs", + "@@rules_rust+//crate_universe:src/cli/query.rs", + "@@rules_rust+//crate_universe:src/cli/render.rs", + "@@rules_rust+//crate_universe:src/cli/splice.rs", + "@@rules_rust+//crate_universe:src/cli/vendor.rs", + "@@rules_rust+//crate_universe:src/config.rs", + "@@rules_rust+//crate_universe:src/context.rs", + "@@rules_rust+//crate_universe:src/context/crate_context.rs", + "@@rules_rust+//crate_universe:src/context/platforms.rs", + "@@rules_rust+//crate_universe:src/lib.rs", + "@@rules_rust+//crate_universe:src/lockfile.rs", + "@@rules_rust+//crate_universe:src/main.rs", + "@@rules_rust+//crate_universe:src/metadata.rs", + "@@rules_rust+//crate_universe:src/metadata/cargo_bin.rs", + "@@rules_rust+//crate_universe:src/metadata/cargo_tree_resolver.rs", + "@@rules_rust+//crate_universe:src/metadata/cargo_tree_rustc_wrapper.bat", + "@@rules_rust+//crate_universe:src/metadata/cargo_tree_rustc_wrapper.sh", + "@@rules_rust+//crate_universe:src/metadata/dependency.rs", + "@@rules_rust+//crate_universe:src/metadata/metadata_annotation.rs", + "@@rules_rust+//crate_universe:src/rendering.rs", + "@@rules_rust+//crate_universe:src/rendering/template_engine.rs", + "@@rules_rust+//crate_universe:src/rendering/templates/module_bzl.j2", + "@@rules_rust+//crate_universe:src/rendering/templates/partials/header.j2", + "@@rules_rust+//crate_universe:src/rendering/templates/partials/module/aliases_map.j2", + "@@rules_rust+//crate_universe:src/rendering/templates/partials/module/deps_map.j2", + "@@rules_rust+//crate_universe:src/rendering/templates/partials/module/repo_git.j2", + "@@rules_rust+//crate_universe:src/rendering/templates/partials/module/repo_http.j2", + "@@rules_rust+//crate_universe:src/rendering/templates/vendor_module.j2", + "@@rules_rust+//crate_universe:src/rendering/verbatim/alias_rules.bzl", + "@@rules_rust+//crate_universe:src/select.rs", + "@@rules_rust+//crate_universe:src/splicing.rs", + "@@rules_rust+//crate_universe:src/splicing/cargo_config.rs", + "@@rules_rust+//crate_universe:src/splicing/crate_index_lookup.rs", + "@@rules_rust+//crate_universe:src/splicing/splicer.rs", + "@@rules_rust+//crate_universe:src/test.rs", + "@@rules_rust+//crate_universe:src/utils.rs", + "@@rules_rust+//crate_universe:src/utils/starlark.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/glob.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/label.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/select.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/select_dict.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/select_list.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/select_scalar.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/select_set.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/serialize.rs", + "@@rules_rust+//crate_universe:src/utils/starlark/target_compatible_with.rs", + "@@rules_rust+//crate_universe:src/utils/symlink.rs", + "@@rules_rust+//crate_universe:src/utils/target_triple.rs" + ], + "binary": "cargo-bazel", + "cargo_lockfile": "@@rules_rust+//crate_universe:Cargo.lock", + "cargo_toml": "@@rules_rust+//crate_universe:Cargo.toml", + "version": "1.86.0", + "timeout": 900, + "rust_toolchain_cargo_template": "@rust_host_tools//:bin/{tool}", + "rust_toolchain_rustc_template": "@rust_host_tools//:bin/{tool}", + "compressed_windows_toolchain_names": false + } + } + }, + "moduleExtensionMetadata": { + "explicitRootModuleDirectDeps": [ + "cargo_bazel_bootstrap" + ], + "explicitRootModuleDirectDevDeps": [], + "useAllRepos": "NO", + "reproducible": false + }, + "recordedRepoMappingEntries": [ + [ + "bazel_features+", + "bazel_features_globals", + "bazel_features++version_extension+bazel_features_globals" + ], + [ + "bazel_features+", + "bazel_features_version", + "bazel_features++version_extension+bazel_features_version" + ], + [ + "rules_cc+", + "bazel_tools", + "bazel_tools" + ], + [ + "rules_cc+", + "cc_compatibility_proxy", + "rules_cc++compatibility_proxy+cc_compatibility_proxy" + ], + [ + "rules_cc+", + "rules_cc", + "rules_cc+" + ], + [ + "rules_cc++compatibility_proxy+cc_compatibility_proxy", + "rules_cc", + "rules_cc+" + ], + [ + "rules_rust+", + "bazel_features", + "bazel_features+" + ], + [ + "rules_rust+", + "bazel_skylib", + "bazel_skylib+" + ], + [ + "rules_rust+", + "bazel_tools", + "bazel_tools" + ], + [ + "rules_rust+", + "cui", + "rules_rust++cu+cui" + ], + [ + "rules_rust+", + "rrc", + "rules_rust++i2+rrc" + ], + [ + "rules_rust+", + "rules_cc", + "rules_cc+" + ], + [ + "rules_rust+", + "rules_rust", + "rules_rust+" + ] + ] + } + }, "@@score_bazel_cpp_toolchains+//extensions:gcc.bzl%gcc": { "general": { "bzlTransitiveDigest": "p454rnAAhdaSDUGVL7ODsicHx4WOTpQ2rl4KprMxb2Y=",