grapl VS cargo-chef

https://github.com/grapl-security/grapl/

I just did a clean build `cargo build`, 19 minutes 44 seconds.

I added 1 line (`dbg!("foo")`) and it took 14.76s

Awesome. So, CURP was pretty inspiring for the work I did on Grapl. Grapl Schemas had to define conflict resolution algorithms.

https://github.com/grapl-security/grapl/blob/main/etc/exampl...

As you can see here, there are some special built-ins that aren't important (keys, timestamps) but you can see there's @immutable (FWW) and @increment_only.

This meant that our graphs formed a big CRDT, which meant that every operation commuted, which meant that we could do weird things with our consensus. Reads could happen on stale data, writes could be dropped, we could read from two inconsistent databases and resolve the inconsistency in memory, etc. I even hacked this into ScyllaDB by encoding each merge function into an integer, and setting that as the TIMESTAMP, for when replication merging happened to the values - this meant we could perform writes (repeatedly) without reading a value first, and with no coordination between nodes. What I didn't have was a native solution that could take advantage of these constraints.

As you can tell, this project is obviously very interesting to me. I ran through this pretty quickly but I'll dig in more soon. I'm just excited to see this.

Rust, Python and Go. Props to you for being sensible with technology choice.

https://github.com/grapl-security/grapl

That's great for you and your team, but looking at https://github.com/grapl-security/grapl it seems like your needs are pretty different from most web developers.

CI time. Do you want to micromanage your own docker images for all your CI? Great! If not, yes you do. In fact, you want to manage a docker image to build a docker image to use for CI. Use cargo-chef to prepare a build image with your dependencies pre-built if you want to do fine-grained build/test pipelines. Oh also, there's no jUnit test report generation, that was killed off today. (YES, SORRY, I'm still salty.)

Have you looked at cargo-chef? It supposedly speeds up compilation times if you're using Docker.

A tool already exists for this called Cargo-chef, and it works extremely well.

At work I've use Dockerfile and cargo-chef to improve build times. You can also look into buildkit cache mounts, but this approach is rarely super effective on hosted CI because they start from scratch on most runs. In the context of Rust specifically you may also see the target directory reflect unbounded data growth if it's reused over and over across revisions. because cargo by default won't expire older intermediate artifacts. Cargo-sweep can help with that but I wouldn't pursue this in a CI effort. This will affect both "native" builds and buildkit cache mounts if you're persisting the target directory.

We create an empty Rust binary with cargo new, this is a simple way to get Docker layer caching to work. For a more robust solution, you may want to check out cargo-chef.

If this ends up being a cleaner/easier way to having to workaround super expensive rebuilds for Rust given cache + deps compared to this https://github.com/LukeMathWalker/cargo-chef , reading this thread will have been a huge win for me (and hopefully others).

Whether introducing Bazel is easier/worth it, subjective I guess.

I did a talk (slides here) about this a few years ago, it took a bit of work to get the build caching working with cargo. As others have pointed out, there is now cargo chef to solve this problem so you probably don't have to deal with the issues I saw, but I thought it still might be helpful context.

I'm curious if you've tried out cargo-chef, I've had some decent improvements with it but I wonder how it stacks up to the sccache approach (don't have the time to try it out myself right now).

for CI have you tried to use buildkit persistent runners with caching + https://github.com/LukeMathWalker/cargo-chef ?

If you're deploying Rust with Docker I can tell you that cargo-chef is invaluable. With zero work it caches the dependency fetch and compilation steps. Most of the time the ens Docker deploy is closer to an incremental compile than full.