1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
use crate::{clone::PrepareCheckout, Repository};
///
pub mod main_worktree {
use std::{path::PathBuf, sync::atomic::AtomicBool};
use gix_odb::FindExt;
use crate::{clone::PrepareCheckout, Progress, Repository};
/// The error returned by [`PrepareCheckout::main_worktree()`].
#[derive(Debug, thiserror::Error)]
#[allow(missing_docs)]
pub enum Error {
#[error("Repository at \"{}\" is a bare repository and cannot have a main worktree checkout", git_dir.display())]
BareRepository { git_dir: PathBuf },
#[error("The object pointed to by HEAD is not a treeish")]
NoHeadTree(#[from] crate::object::peel::to_kind::Error),
#[error("Could not create index from tree at {id}")]
IndexFromTree {
id: gix_hash::ObjectId,
source: gix_traverse::tree::breadthfirst::Error,
},
#[error(transparent)]
WriteIndex(#[from] gix_index::file::write::Error),
#[error(transparent)]
CheckoutOptions(#[from] crate::config::checkout_options::Error),
#[error(transparent)]
IndexCheckout(
#[from] gix_worktree::checkout::Error<gix_odb::find::existing_object::Error<gix_odb::store::find::Error>>,
),
#[error("Failed to reopen object database as Arc (only if thread-safety wasn't compiled in)")]
OpenArcOdb(#[from] std::io::Error),
#[error("The HEAD reference could not be located")]
FindHead(#[from] crate::reference::find::existing::Error),
#[error("The HEAD reference could not be located")]
PeelHeadToId(#[from] crate::head::peel::Error),
}
/// The progress ids used in [`PrepareCheckout::main_worktree()`].
///
/// Use this information to selectively extract the progress of interest in case the parent application has custom visualization.
#[derive(Debug, Copy, Clone)]
pub enum ProgressId {
/// The amount of files checked out thus far.
CheckoutFiles,
/// The amount of bytes written in total, the aggregate of the size of the content of all files thus far.
BytesWritten,
}
impl From<ProgressId> for gix_features::progress::Id {
fn from(v: ProgressId) -> Self {
match v {
ProgressId::CheckoutFiles => *b"CLCF",
ProgressId::BytesWritten => *b"CLCB",
}
}
}
/// Modification
impl PrepareCheckout {
/// Checkout the main worktree, determining how many threads to use by looking at `checkout.workers`, defaulting to using
/// on thread per logical core.
///
/// Note that this is a no-op if the remote was empty, leaving this repository empty as well. This can be validated by checking
/// if the `head()` of the returned repository is not unborn.
pub fn main_worktree(
&mut self,
mut progress: impl crate::Progress,
should_interrupt: &AtomicBool,
) -> Result<(Repository, gix_worktree::checkout::Outcome), Error> {
let repo = self
.repo
.as_ref()
.expect("still present as we never succeeded the worktree checkout yet");
let workdir = repo.work_dir().ok_or_else(|| Error::BareRepository {
git_dir: repo.git_dir().to_owned(),
})?;
let root_tree = match repo.head()?.peel_to_id_in_place().transpose()? {
Some(id) => id.object().expect("downloaded from remote").peel_to_tree()?.id,
None => {
return Ok((
self.repo.take().expect("still present"),
gix_worktree::checkout::Outcome::default(),
))
}
};
let index = gix_index::State::from_tree(&root_tree, |oid, buf| repo.objects.find_tree_iter(oid, buf).ok())
.map_err(|err| Error::IndexFromTree {
id: root_tree,
source: err,
})?;
let mut index = gix_index::File::from_state(index, repo.index_path());
let mut opts = repo.config.checkout_options(repo.git_dir())?;
opts.destination_is_initially_empty = true;
let mut files = progress.add_child_with_id("checkout", ProgressId::CheckoutFiles.into());
let mut bytes = progress.add_child_with_id("writing", ProgressId::BytesWritten.into());
files.init(Some(index.entries().len()), crate::progress::count("files"));
bytes.init(None, crate::progress::bytes());
let start = std::time::Instant::now();
let outcome = gix_worktree::checkout(
&mut index,
workdir,
{
let objects = repo.objects.clone().into_arc()?;
move |oid, buf| objects.find_blob(oid, buf)
},
&mut files,
&mut bytes,
should_interrupt,
opts,
)?;
files.show_throughput(start);
bytes.show_throughput(start);
index.write(Default::default())?;
Ok((self.repo.take().expect("still present"), outcome))
}
}
}
/// Access
impl PrepareCheckout {
/// Get access to the repository while the checkout isn't yet completed.
///
/// # Panics
///
/// If the checkout is completed and the [`Repository`] was already passed on to the caller.
pub fn repo(&self) -> &Repository {
self.repo
.as_ref()
.expect("present as checkout operation isn't complete")
}
}
/// Consumption
impl PrepareCheckout {
/// Persist the contained repository as is even if an error may have occurred when checking out the main working tree.
pub fn persist(mut self) -> Repository {
self.repo.take().expect("present and consumed once")
}
}
impl Drop for PrepareCheckout {
fn drop(&mut self) {
if let Some(repo) = self.repo.take() {
std::fs::remove_dir_all(repo.work_dir().unwrap_or_else(|| repo.path())).ok();
}
}
}
impl From<PrepareCheckout> for Repository {
fn from(prep: PrepareCheckout) -> Self {
prep.persist()
}
}
|
