Trait jj_lib::backend::Backend

pub trait Backend: Send + Sync + Debug {
    // Required methods
    fn as_any(&self) -> &dyn Any;
    fn name(&self) -> &str;
    fn commit_id_length(&self) -> usize;
    fn change_id_length(&self) -> usize;
    fn root_commit_id(&self) -> &CommitId;
    fn root_change_id(&self) -> &ChangeId;
    fn empty_tree_id(&self) -> &TreeId;
    fn concurrency(&self) -> usize;
    fn read_file<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        path: &'life1 RepoPath,
        id: &'life2 FileId
    ) -> Pin<Box<dyn Future<Output = BackendResult<Box<dyn Read>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn write_file(
        &self,
        path: &RepoPath,
        contents: &mut dyn Read
    ) -> BackendResult<FileId>;
    fn read_symlink<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        path: &'life1 RepoPath,
        id: &'life2 SymlinkId
    ) -> Pin<Box<dyn Future<Output = BackendResult<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn write_symlink(
        &self,
        path: &RepoPath,
        target: &str
    ) -> BackendResult<SymlinkId>;
    fn read_tree<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        path: &'life1 RepoPath,
        id: &'life2 TreeId
    ) -> Pin<Box<dyn Future<Output = BackendResult<Tree>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn write_tree(
        &self,
        path: &RepoPath,
        contents: &Tree
    ) -> BackendResult<TreeId>;
    fn read_conflict(
        &self,
        path: &RepoPath,
        id: &ConflictId
    ) -> BackendResult<Conflict>;
    fn write_conflict(
        &self,
        path: &RepoPath,
        contents: &Conflict
    ) -> BackendResult<ConflictId>;
    fn read_commit<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 CommitId
    ) -> Pin<Box<dyn Future<Output = BackendResult<Commit>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn write_commit(
        &self,
        contents: Commit,
        sign_with: Option<&mut SigningFn<'_>>
    ) -> BackendResult<(CommitId, Commit)>;
    fn gc(&self, index: &dyn Index, keep_newer: SystemTime) -> BackendResult<()>;
}

Defines the interface for commit backends.

Required Methods

fn as_any(&self) -> &dyn Any

fn name(&self) -> &str

A unique name that identifies this backend. Written to .jj/repo/store/backend when the repo is created.

fn commit_id_length(&self) -> usize

The length of commit IDs in bytes.

fn change_id_length(&self) -> usize

The length of change IDs in bytes.

fn root_commit_id(&self) -> &CommitId

fn root_change_id(&self) -> &ChangeId

fn empty_tree_id(&self) -> &TreeId

fn concurrency(&self) -> usize

An estimate of how many concurrent requests this backend handles well. A local backend like the Git backend (at until it supports partial clones) may want to set this to 1. A cloud-backed backend may want to set it to 100 or so.

It is not guaranteed that at most this number of concurrent requests are sent.

fn read_file<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, path: &'life1 RepoPath, id: &'life2 FileId ) -> Pin<Box<dyn Future<Output = BackendResult<Box<dyn Read>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn write_file( &self, path: &RepoPath, contents: &mut dyn Read ) -> BackendResult<FileId>

fn read_symlink<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, path: &'life1 RepoPath, id: &'life2 SymlinkId ) -> Pin<Box<dyn Future<Output = BackendResult<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn write_symlink( &self, path: &RepoPath, target: &str ) -> BackendResult<SymlinkId>

fn read_tree<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, path: &'life1 RepoPath, id: &'life2 TreeId ) -> Pin<Box<dyn Future<Output = BackendResult<Tree>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn write_tree(&self, path: &RepoPath, contents: &Tree) -> BackendResult<TreeId>

fn read_conflict( &self, path: &RepoPath, id: &ConflictId ) -> BackendResult<Conflict>

fn write_conflict( &self, path: &RepoPath, contents: &Conflict ) -> BackendResult<ConflictId>

fn read_commit<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 CommitId ) -> Pin<Box<dyn Future<Output = BackendResult<Commit>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn write_commit( &self, contents: Commit, sign_with: Option<&mut SigningFn<'_>> ) -> BackendResult<(CommitId, Commit)>

Writes a commit and returns its ID and the commit itself. The commit should contain the data that was actually written, which may differ from the data passed in. For example, the backend may change the committer name to an authenticated user’s name, or the backend’s timestamps may have less precision than the millisecond precision in Commit.

The sign_with parameter could contain a function to cryptographically sign some binary representation of the commit. If the backend supports it, it could call it and store the result in an implementation specific fashion, and both read_commit and the return of write_commit should read it back as the secure_sig field.

fn gc(&self, index: &dyn Index, keep_newer: SystemTime) -> BackendResult<()>

Perform garbage collection.

All commits found in the index won’t be removed. In addition to that, objects created after keep_newer will be preserved. This mitigates a risk of deleting new commits created concurrently by another process.

Implementors

impl Backend for GitBackend

impl Backend for LocalBackend