# Import process

1. `git pull` to pull a new version from sso://team/beto-rust-devs/beto-rust

## If the dependency tree did not change significantly

2. It will be easier to manually update the Android.bp file to include the new dependencies.
   For each new library that is needed, add it to the `rustlibs` section of the build rule. The
   build rule is typically `lib<crate_name>`, but sometimes variants with different features exist,
   in which case you will have to look up the target name in the relevent `Android.bp` file in code
   search.

## If the dependency tree changed significantly

2. Locally check out the `beto-core-staging` project, and run `scripts/prepare-boringssl.sh`.
4. Modify `.cargo/config.toml` to point to the external `rust-openssl` and `bssl-sys` crates.
5. Run `cargo2android.py --config cargo2android.json`
6. There are probably going to be merge conflicts. Fix them manually. Remove the
   "Do not modify this file" comment added by cargo2android.json
7. Also modify `patches/Android.bp.patch` to include your manual changes.
8. Remove `cargo.out` and `target.tmp`, as those should not be checked in

# Nearby Rust

## Folder Structure

Root repo of the nearby Rust components, folder structure:

`/connections` nearby connections rust components

`/crypto` shared crypto components

`/presence` nearby presence rust components

## Setup

### Toolchain

If you don't already have a Rust toolchain, see [rustup.rs](https://rustup.rs/).

### Cargo

Install [`cargo-deny`](https://github.com/EmbarkStudios/cargo-deny)
and [`cargo-fuzz`](https://github.com/rust-fuzz/cargo-fuzz):

```
cargo install --locked cargo-deny
cargo install cargo-fuzz
```

### Setting up a Docker dev environment

Our project requires specific versions of system dependencies like OpenSSL and
protobuf in order to build correctly. To make the setup of this easier you can
use Docker to handle setting up the environment in a container.

First install Docker then build and run the image from repo root:

```
sudo docker build -t nearby_rust:v1.0 .
sudo docker run --rm -it nearby_rust:v1.0
```

Building the image creates a snapshot of the environment that has all of the
system dependencies needed to start building and running all of the artifacts in
the codebase.

Running the image runs `cargo run -- check-everything` to verify all of the targets can
successfully build and all of the tests pass in your new container environment.

To open a bash shell from the container environment:

```
sudo docker run -it nearby_rust:v1.0 bash
```

You can also setup VSCode
to [develop in a Docker container on a remote host](https://code.visualstudio.com/remote/advancedcontainers/develop-remote-host)
that way you can make code changes and test them in the same environment without
having to re-build the image.

## Common tasks

See `cargo run -- --help` for all the available subcommands.

Check everything:

```
cargo run -- check-everything
```

Build everything:

```
cargo build --workspace --all-targets
```

Run tests:

```
cargo test --workspace
```

Generate Docs:

```
cargo doc --no-deps --workspace --open
```

Run linter on dependencies as configured in `deny.toml` <br>
This will make sure all of our dependencies are using valid licenses and check
for known existing security
vulnerabilities, bugs and deprecated versions

```
cargo deny --workspace check
```

Update dependencies in `Cargo.lock` to their latest in the currently specified
version ranges (i.e. transitive deps):

```
cargo update
```

Check for outdated dependencies
with [cargo-outdated](https://github.com/kbknapp/cargo-outdated):

```
cargo outdated
```

## Benchmarks

Benchmarks are in `benches`, and use
[Criterion](https://bheisler.github.io/criterion.rs/book/getting_started.html) .

```
cargo bench --workspace
```