Struct GitBackend 

pub struct GitBackend { /* private fields */ }

Implementations

impl GitBackend

pub const NAME: &str = "git"

pub fn init_internal( settings: &UserSettings, store_path: &Path, object_hash: Kind, ) -> Result<Self, Box<GitBackendInitError>>

pub fn init_colocated( settings: &UserSettings, store_path: &Path, workspace_root: &Path, object_hash: Kind, ) -> Result<Self, Box<GitBackendInitError>>

Initializes backend by creating a new Git repo at the specified workspace path. The workspace directory must exist.

pub fn init_external( settings: &UserSettings, store_path: &Path, git_repo_path: &Path, ) -> Result<Self, Box<GitBackendInitError>>

Initializes backend with an existing Git repo at the specified path.

pub fn load( settings: &UserSettings, store_path: &Path, ) -> Result<Self, Box<GitBackendLoadError>>

pub fn git_repo(&self) -> Repository

Returns a new thread-local handle for the underlying Git repository.

Use Self::open_git_repo_at_workdir() for worktree operations.

pub fn open_git_repo_at_workdir( &self, path: &Path, ) -> Result<Repository, GitRepoAtWorkdirError>

Reopens the repository at the given workspace path. Returns a new thread-local handle.

pub fn git_repo_path(&self) -> &Path

Path to the .git directory or the repository itself if it’s bare.

pub fn import_head_commits<'a>( &self, head_ids: impl IntoIterator<Item = &'a CommitId>, ) -> BackendResult<()>

Imports the given commits and ancestors from the backing Git repo.

The head_ids may contain commits that have already been imported, but the caller should filter them out to eliminate redundant I/O processing.

impl GitBackend

pub 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.

Trait Implementations

impl Backend for GitBackend

fn name(&self) -> &str

A unique name that identifies this backend. Written to .jj/repo/store/type 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

The root commit’s ID.

fn root_change_id(&self) -> &ChangeId

The root commit’s change ID.

fn empty_tree_id(&self) -> &TreeId

The empty tree’s ID. All empty trees must have the same ID regardless of the path.

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 guaranteed to return at least 1.

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

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

Returns a reader for reading the contents of a file from the backend.

fn write_file<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _path: &'life1 RepoPath, contents: &'life2 mut (dyn AsyncRead + Send + Unpin), ) -> Pin<Box<dyn Future<Output = BackendResult<FileId>> + Send + 'async_trait>>

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

Writes the contents of the writer to the backend. Returns the ID of the written file.

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,

Reads the target of a symlink from the backend. Returns the target path. It is not a RepoPath because it doesn’t necessarily point within the repository.

fn write_symlink<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _path: &'life1 RepoPath, target: &'life2 str, ) -> Pin<Box<dyn Future<Output = BackendResult<SymlinkId>> + Send + 'async_trait>>

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

Writes a symlink with the given target to the backend and returns its ID.

fn read_copy<'life0, 'life1, 'async_trait>( &'life0 self, _id: &'life1 CopyId, ) -> Pin<Box<dyn Future<Output = BackendResult<CopyHistory>> + Send + 'async_trait>>

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

Read the specified CopyHistory object.

fn write_copy<'life0, 'life1, 'async_trait>( &'life0 self, _contents: &'life1 CopyHistory, ) -> Pin<Box<dyn Future<Output = BackendResult<CopyId>> + Send + 'async_trait>>

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

Write the CopyHistory object and return its ID.

fn get_related_copies<'life0, 'life1, 'async_trait>( &'life0 self, _copy_id: &'life1 CopyId, ) -> Pin<Box<dyn Future<Output = BackendResult<Vec<RelatedCopy>>> + Send + 'async_trait>>

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

Find all copy histories that are related to the specified one. This is defined as those that are ancestors of the given specified one, plus all descendants of those ancestors. Children must be returned before parents, and the order should be deterministic.

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,

Reads the tree at the given path with the given ID.

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

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

Writes the given tree at the given path to the backend and returns its ID.

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,

Reads the commit with the given ID.

fn write_commit<'life0, 'life1, 'async_trait>( &'life0 self, contents: Commit, sign_with: Option<&'life1 mut SigningFn<'_>>, ) -> Pin<Box<dyn Future<Output = BackendResult<(CommitId, Commit)>> + Send + 'async_trait>>

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

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.

fn get_copy_records( &self, paths: Option<&[RepoPathBuf]>, root_id: &CommitId, head_id: &CommitId, ) -> BackendResult<BoxStream<'_, BackendResult<CopyRecord>>>

Get copy records for the dag range root..head. If paths is None include all paths, otherwise restrict to only paths.

impl Debug for GitBackend

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.