To what extent is rustic aiming to be cli (or API) compatible with restic?

[garethgeorge]

Hi! Backrest author here (see backrest. I've gotten a few feature requests re: supporting rustic, I'm reaching out to understand what this project's road map looks like and , in particular , to what extent operational preserving a similar interface to restic is a goal.

My main questions are:

• how stable is rustic's API today / will it change dramatically in the future?
• will rustic maintain a set of operations (and provide status information) that is roughly analogous to what restic provides today?

The important commands Backrest uses are:

• backup -- backrest parses progress events as a JSON feed from the backup command's output
• forget -- backrest parses the output of forget snapshots to understand which snapshots have been removed.
• snapshots -- backrest parses the output of restic snapshots to index the contents of a repository.
• prune -- backrest executes prune commands with minimal processing of the output

My most likely pathway to rustic support would probably be creating an FFI bridge from Go to Rustic's Rust API. I'd aim to wrangle rustic's output into a shape that looks a lot like what I'm getting from restic today. All of my Go code for doing this today lives in here but my understanding is that rustic is available as a crate -- so I should be able to statically link it rather than spawning a binary?

[aawsome]

Thanks for opening this discussion @garethgeorge

Generally, CLI compatibility with restic is not a goal even though many things work pretty similar or equal. For a feature comparison, see https://rustic.cli.rs/docs/comparison-restic.html.

I would advise to use the APIs provided by the crates rustic_core and rustic_backend which also has the benefit that it allows you to compile everything into a single binary. However, I do think that a main work task is to build a FFI layer to make them accessible from Go. I would advise to build a separate package for this. Note that we can support you in building this layer (especially the interfaces to the crates), but it is not our main scope, of course.

About API-stability: We don't guarantee API-stability at the moment as we are still in an early phase. So far, the crates are not used by many other crates and we would like to adapt things once there are more users and API-improvement-requests reach us. (You are also very much invited to propose changes if you find some things non-optimal!) That said, there are many functionalities which are already pretty stable and where I don't expect major changes w.r.t the functionality.

About the specific functionality:

general/progress:

• You should start by getting a Repository which basically allows all operations on it.
• Using Repository::new_with_progress you can give your own progress handler. This is basically a call-back which is called for every kind of progress made during operations (like reading index/backup/prune, etc). All progressbars which rustic shows are completely implemented in the CLI and just use this functionality.
• Note that a Repository can be in different states (Open, Indexed etc.) and only operations valid for that state will work. E.g. if you want to backup, you must turn the Repository into an indexed state, in this case Repository::to_indexed_ids which will read all index files and returns a Repository object in the right state.

snapshots:

If you like to get the snapshots grouped, there is Repository::get_snapshot_group. But Repository::get_all_snapshots simply gives all snapshots, so you can do what you want with them. SnapshotFile contains all information present in the snapshot JSON.

backup:

Simply use Repository::backup

forget:

Repository::get_forget_snapshots returns all snapshots with reasons why a snapshot is kept or to be removed (see ForgetSnapshot). To remove a list of snapshots, use Repository::delete_snapshots - note that you can use ForgetGroups::into_forget_ids.

prune:

To just call it, use Repository::prune_plan followed by PrunePlan::do_prune to execute the plan.

I'd also advise you to have a look at the examples or the CLI implementation which show how to use the Repository methods.