workspace.rs 86.7%

221 of 255 lines run, 37 of 54 functions · run #409 on main · run missed

//! Multiple workspaces (spec §12.2): extra checkout directories sharing one
//! `.oxy`. A secondary workspace holds a `.oxy` *file* of the form
//! `oxydir: <path>\nworkspace: <id>`; the repository lists workspaces under
//! `.oxy/workspaces/<id>/path`. Each workspace has its own working-copy
//! change, manifest, and short-lived snapshot lock.

use super::*;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct WorkspaceInfo {
    pub id: WorkspaceId,
    pub path: PathBuf,
    /// Working-copy change hash from the current view, if the workspace is registered there.
    pub working_copy: Option<ChangeHash>,
    pub current: bool,
}

/// A lock file, taken by creating it exclusively and released on drop: a
/// workspace's working-copy lock, the operation head's lock. A stale one,
/// whose process is gone (or, where that cannot be told, older than a
/// minute), is taken over.
pub struct FileLock {
    path: PathBuf,
}

/// A workspace's working-copy lock (spec §12.1), held by everything that
/// reads or writes the working copy and records its working-copy change:
/// snapshot, checkout, bookmark switch, commit, discard, pull. It is
/// re-entrant within a thread, so a checkout that snapshots first holds it
/// once.
pub struct WorkingCopyLock {
    path: PathBuf,
    _file: Option<FileLock>,
}

/// The working-copy lock; its old name.
pub type SnapshotLock = WorkingCopyLock;

thread_local! {
    /// Working-copy locks this thread holds, with their depth.
    static HELD: std::cell::RefCell<HashMap<PathBuf, usize>> = Default::default();
}

impl Drop for WorkingCopyLock {
    fn drop(&mut self) {
        HELD.with(|h| {
            let mut h = h.borrow_mut();
            if let Some(n) = h.get_mut(&self.path) {
                *n -= 1;
                if *n == 0 {
                    h.remove(&self.path);
                }
            }
        });
    }
}

/// Whether the process that wrote a lock file is gone. Where that cannot
/// be told (no `/proc`), a lock older than a minute counts as stale.
pub(crate) fn lock_is_stale(path: &Path) -> bool {
    let old = fs::metadata(path)
        .and_then(|m| m.modified())
        .map(|t| t.elapsed().map(|d| d.as_secs() > 60).unwrap_or(false))
        .unwrap_or(true);
    let proc_fs = Path::new("/proc/self").exists();
    match fs::read_to_string(path)
        .ok()
        .and_then(|s| s.trim().parse::<u32>().ok())
    {
        Some(pid) if proc_fs => !Path::new("/proc").join(pid.to_string()).exists(),
        // Being written this instant, or by something that is not oxy.
        _ => old,
    }
}

impl Drop for FileLock {
    fn drop(&mut self) {
        let _ = fs::remove_file(&self.path);
    }
}

impl FileLock {
    /// Wait up to about five seconds for `path`; `busy` is the error after that.
    pub(crate) fn acquire(path: PathBuf, busy: &str) -> Result<FileLock> {
        Self::acquire_within(path, busy, std::time::Duration::from_secs(5))
    }

    /// Wait up to `wait` for `path`; `busy` is the error after that.
    pub(crate) fn acquire_within(
        path: PathBuf,
        busy: &str,
        wait: std::time::Duration,
    ) -> Result<FileLock> {
        let until = std::time::Instant::now() + wait;
        loop {
            match fs::OpenOptions::new()
                .write(true)
                .create_new(true)
                .open(&path)
            {
                Ok(mut f) => {
                    let _ = write!(f, "{}", std::process::id());
                    return Ok(FileLock { path });
                }
                Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
                    if lock_is_stale(&path) {
                        let _ = fs::remove_file(&path);
                        continue;
                    }
                    if std::time::Instant::now() >= until {
                        return fail(busy);
                    }
                    std::thread::sleep(std::time::Duration::from_millis(10));
                }
                Err(e) => return Err(e.into()),
            }
        }
    }
}

/// Parse a secondary workspace's `.oxy` file.
pub(crate) fn parse_workspace_file(text: &str) -> Option<(PathBuf, WorkspaceId)> {
    let mut dir = None;
    let mut id = None;
    for line in text.lines() {
        if let Some(v) = line.strip_prefix("oxydir:") {
            dir = Some(PathBuf::from(v.trim()));
        } else if let Some(v) = line.strip_prefix("workspace:") {
            id = WorkspaceId::from_hex(v.trim());
        }
    }
    Some((dir?, id?))
}

impl Repo {
    fn workspace_dir(&self, id: &WorkspaceId) -> PathBuf {
        self.oxy.join("workspaces").join(id.to_hex())
    }

    /// Record where a workspace lives.
    pub(crate) fn register_workspace(&self, id: &WorkspaceId, path: &Path) -> Result<()> {
        let dir = self.workspace_dir(id);
        fs::create_dir_all(&dir)?;
        write_atomic(&dir.join("path"), path.to_string_lossy().as_bytes())
    }

    /// The directory of a workspace, if registered.
    pub fn workspace_path(&self, id: &WorkspaceId) -> Option<PathBuf> {
        fs::read_to_string(self.workspace_dir(id).join("path"))
            .ok()
            .map(|s| PathBuf::from(s.trim()))
    }

    /// Every workspace this repository knows about.
    pub fn workspaces(&self) -> Result<Vec<WorkspaceInfo>> {
        let view = self.view()?;
        let mut ids: BTreeSet<WorkspaceId> = view.workspaces.keys().copied().collect();
        if let Ok(rd) = fs::read_dir(self.oxy.join("workspaces")) {
            for e in rd.flatten() {
                if let Some(id) = WorkspaceId::from_hex(&e.file_name().to_string_lossy()) {
                    if e.path().join("path").exists() {
                        ids.insert(id);
                    }
                }
            }
        }
        let mut out = Vec::new();
        for id in ids {
            let path = if id == self.workspace {
                self.root.clone()
            } else {
                self.workspace_path(&id)
                    .unwrap_or_else(|| PathBuf::from("(unknown)"))
            };
            out.push(WorkspaceInfo {
                id,
                path,
                working_copy: view.workspaces.get(&id).copied(),
                current: id == self.workspace,
            });
        }
        Ok(out)
    }

    /// Create a workspace at `dir` checked out on `heads` (default the
    /// bookmark's), and return a `Repo` rooted there.
    /// `bookmark` is the new workspace's current bookmark (oxygen#60), by
    /// default this workspace's.
    pub fn workspace_add(&self, dir: &Path, heads: Option<&[ChangeHash]>) -> Result<Repo> {
        self.workspace_add_on(dir, heads, None)
    }

    /// [`Repo::workspace_add`] with the new workspace on `bookmark`.
    pub fn workspace_add_on(
        &self,
        dir: &Path,
        heads: Option<&[ChangeHash]>,
        bookmark: Option<&str>,
    ) -> Result<Repo> {
        if dir.exists() && fs::read_dir(dir)?.next().is_some() {
            return fail(format!("{} exists and is not empty", dir.display()));
        }
        fs::create_dir_all(dir)?;
        let dir = crate::portable::canonical(dir)?;
        if dir == self.root || dir.starts_with(&self.root) || self.root.starts_with(&dir) {
            return fail("a workspace cannot be inside another workspace of the same repository");
        }
        let heads = match heads {
            Some(h) => h.to_vec(),
            None => self.bookmark_heads()?,
        };
        let id = WorkspaceId::random();
        // On nothing, as the directory is, until the checkout: on `heads`,
        // the checkout's first snapshot found every file of the tree
        // deleted, rendering the whole tree to say so (195 s of a 467 s
        // `oxy workspace add` in the VS Code history, oxygen#137).
        let wc = self.new_working_copy(Vec::new(), "");
        let wc_hash = self.store.put_change(&wc)?;
        let (op_ref, op) = self.head_op()?;
        let mut view = op.view.clone();
        view.workspaces.insert(id, wc_hash);
        self.record_op(
            &[op_ref],
            &format!("oxy workspace add {}", dir.display()),
            view,
        )?;
        self.register_workspace(&id, &dir)?;
        self.set_workspace_bookmark(&id, bookmark.unwrap_or(&self.config.bookmark))?;
        write_atomic(
            &dir.join(OXY_DIR),
            format!(
                "oxydir: {}\nworkspace: {}\n",
                self.oxy.display(),
                id.to_hex()
            )
            .as_bytes(),
        )?;
        let repo = Repo::open(&dir)?.with_home(self.keys_dir.parent().unwrap_or(&self.keys_dir));
        repo.checkout(&heads, true, "oxy workspace add (checkout)")?;
        self.copy_subrepos_into(&repo);
        Ok(repo)
    }

    /// The new workspace's subrepos at their pins, from this workspace's
    /// own copies (oxygen#61): a local clone, its remote then pointed at
    /// the subrepo's URL, and the pin checked out, with no network unless
    /// this copy lacks the pinned changes. A subrepo this workspace does
    /// not have stays for `oxy submodule update --init`. Best effort.
    fn copy_subrepos_into(&self, new: &Repo) {
        let Ok(subs) = new.subrepos() else { return };
        let modules = new.modules_on_disk();
        for s in subs {
            let (src, dst) = (self.root.join(&s.path), new.root.join(&s.path));
            if dst.join(OXY_DIR).exists() || dst.join(".git").exists() {
                continue;
            }
            let url = modules.entries.get(&s.path).map(|m| m.url.clone());
            if let Some(parent) = dst.parent() {
                let _ = fs::create_dir_all(parent);
            }
            let _ = fs::remove_dir(&dst);
            if src.join(OXY_DIR).exists() {
                match Repo::clone(&src.to_string_lossy(), &dst) {
                    Ok(mut sub) => {
                        if let Some(u) = &url {
                            if sub.config.set("remote.origin.url", u).is_ok() {
                                let _ = sub.save_config();
                            }
                        }
                    }
                    Err(_) => continue,
                }
            } else if src.join(".git").exists() {
                let cloned = std::process::Command::new("git")
                    .args(["clone", "-q", "--local"])
                    .arg(&src)
                    .arg(&dst)
                    .status()
                    .is_ok_and(|st| st.success());
                if !cloned {
                    continue;
                }
                if let Some(u) = &url {
                    let _ = std::process::Command::new("git")
                        .arg("-C")
                        .arg(&dst)
                        .args(["remote", "set-url", "origin", u])
                        .status();
                }
            } else {
                continue;
            }
            let _ = new.sync_subrepo(&s.path, &s.pin, false);
        }
    }

    /// Drop a workspace from the view and registry; its files stay.
    pub fn workspace_forget(&self, id: &WorkspaceId) -> Result<()> {
        if *id == self.workspace {
            return fail("cannot forget the workspace you are in");
        }
        let (op_ref, op) = self.head_op()?;
        let mut view = op.view.clone();
        if view.workspaces.remove(id).is_none() && self.workspace_path(id).is_none() {
            return fail(format!("no workspace {}", id.short(8)));
        }
        self.record_op(
            &[op_ref],
            &format!("oxy workspace forget {}", id.short(8)),
            view,
        )?;
        let _ = fs::remove_dir_all(self.workspace_dir(id));
        Ok(())
    }

    /// Take this workspace's snapshot lock (spec §12.1).
    pub(crate) fn lock_snapshot(&self) -> Result<SnapshotLock> {
        self.lock_working_copy()
    }

    /// Take this workspace's working-copy lock (spec §12.1), waiting up to
    /// a minute for another process's checkout or snapshot to finish.
    pub fn lock_working_copy(&self) -> Result<WorkingCopyLock> {
        let dir = self.workspace_dir(&self.workspace);
        if self.bare {
            // No working copy to guard.
            return Ok(WorkingCopyLock {
                path: dir,
                _file: None,
            });
        }
        fs::create_dir_all(&dir)?;
        let path = dir.join("lock");
        let held = HELD.with(|h| {
            let mut h = h.borrow_mut();
            match h.get_mut(&path) {
                Some(n) => {
                    *n += 1;
                    true
                }
                None => false,
            }
        });
        if held {
            return Ok(WorkingCopyLock { path, _file: None });
        }
        let file = FileLock::acquire_within(
            path.clone(),
            "another oxy process is using this working copy (a checkout or snapshot); try again when it finishes",
            std::time::Duration::from_secs(60),
        )?;
        HELD.with(|h| h.borrow_mut().insert(path.clone(), 1));
        // Whoever held the lock may have moved the operation head: what
        // is done under it starts from the head as it is now (oxygenhub#249).
        self.forget_head();
        Ok(WorkingCopyLock {
            path,
            _file: Some(file),
        })
    }
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! Multiple workspaces (spec §12.2): extra checkout directories sharing one
2		//! `.oxy`. A secondary workspace holds a `.oxy` file of the form
3		//! `oxydir: <path>\nworkspace: <id>`; the repository lists workspaces under
4		//! `.oxy/workspaces/<id>/path`. Each workspace has its own working-copy
5		//! change, manifest, and short-lived snapshot lock.
6
7		use super::*;
8
9		#[derive(Debug, Clone, PartialEq, Eq)]
10		pub struct WorkspaceInfo {
11		pub id: WorkspaceId,
12		pub path: PathBuf,
13		/// Working-copy change hash from the current view, if the workspace is registered there.
14		pub working_copy: Option<ChangeHash>,
15		pub current: bool,
16		}
17
18		/// A lock file, taken by creating it exclusively and released on drop: a
19		/// workspace's working-copy lock, the operation head's lock. A stale one,
20		/// whose process is gone (or, where that cannot be told, older than a
21		/// minute), is taken over.
22		pub struct FileLock {
23		path: PathBuf,
24		}
25
26		/// A workspace's working-copy lock (spec §12.1), held by everything that
27		/// reads or writes the working copy and records its working-copy change:
28		/// snapshot, checkout, bookmark switch, commit, discard, pull. It is
29		/// re-entrant within a thread, so a checkout that snapshots first holds it
30		/// once.
31		pub struct WorkingCopyLock {
32		path: PathBuf,
33		_file: Option<FileLock>,
34		}
35
36		/// The working-copy lock; its old name.
37		pub type SnapshotLock = WorkingCopyLock;
38
39		thread_local! {
40		/// Working-copy locks this thread holds, with their depth.
41		static HELD: std::cell::RefCell<HashMap<PathBuf, usize>> = Default::default();
42		}
43
44		impl Drop for WorkingCopyLock {
45	3267×	fn drop(&mut self) {
46	3267×	HELD.with(\|h\| {
47	3267×	let mut h = h.borrow_mut();
48	3267×	if let Some(n) = h.get_mut(&self.path) {
49	3266×	*n -= 1;
50	3266×	if *n == 0 {
51	1868×	h.remove(&self.path);
52	1868×	}
53	1×	}
54	3267×	});
55	3267×	}
56		}
57
58		/// Whether the process that wrote a lock file is gone. Where that cannot
59		/// be told (no `/proc`), a lock older than a minute counts as stale.
60	296×	pub(crate) fn lock_is_stale(path: &Path) -> bool {
61	296×	let old = fs::metadata(path)
62	296×	.and_then(\|m\| m.modified())
63	296×	.map(\|t\| t.elapsed().map(\|d\| d.as_secs() > 60).unwrap_or(false))
64	296×	.unwrap_or(true);
65	296×	let proc_fs = Path::new("/proc/self").exists();
66	296×	match fs::read_to_string(path)
67	296×	.ok()
68	296×	.and_then(\|s\| s.trim().parse::<u32>().ok())
69		{
70	296×	Some(pid) if proc_fs => !Path::new("/proc").join(pid.to_string()).exists(),
71		// Being written this instant, or by something that is not oxy.
72	0×	_ => old,
73		}
74	296×	}
75
76		impl Drop for FileLock {
77	5896×	fn drop(&mut self) {
78	5896×	let _ = fs::remove_file(&self.path);
79	5896×	}
80		}
81
82		impl FileLock {
83		/// Wait up to about five seconds for `path`; `busy` is the error after that.
84	4028×	pub(crate) fn acquire(path: PathBuf, busy: &str) -> Result<FileLock> {
85	4028×	Self::acquire_within(path, busy, std::time::Duration::from_secs(5))
86	4028×	}
87
88		/// Wait up to `wait` for `path`; `busy` is the error after that.
89	5896×	pub(crate) fn acquire_within(
90	5896×	path: PathBuf,
91	5896×	busy: &str,
92	5896×	wait: std::time::Duration,
93	5896×	) -> Result<FileLock> {
94	5896×	let until = std::time::Instant::now() + wait;
95		loop {
96	6191×	match fs::OpenOptions::new()
97	6191×	.write(true)
98	6191×	.create_new(true)
99	6191×	.open(&path)
100		{
101	5896×	Ok(mut f) => {
102	5896×	let _ = write!(f, "{}", std::process::id());
103	5896×	return Ok(FileLock { path });
104		}
105	295×	Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
106	295×	if lock_is_stale(&path) {
107	1×	let _ = fs::remove_file(&path);
108	1×	continue;
109	294×	}
110	294×	if std::time::Instant::now() >= until {
111	0×	return fail(busy);
112	294×	}
113	294×	std::thread::sleep(std::time::Duration::from_millis(10));
114		}
115	0×	Err(e) => return Err(e.into()),
116		}
117		}
118	5896×	}
119		}
120
121		/// Parse a secondary workspace's `.oxy` file.
122	9×	pub(crate) fn parse_workspace_file(text: &str) -> Option<(PathBuf, WorkspaceId)> {
123	9×	let mut dir = None;
124	9×	let mut id = None;
125	18×	for line in text.lines() {
126	18×	if let Some(v) = line.strip_prefix("oxydir:") {
127	9×	dir = Some(PathBuf::from(v.trim()));
128	9×	} else if let Some(v) = line.strip_prefix("workspace:") {
129	9×	id = WorkspaceId::from_hex(v.trim());
130	9×	}
131		}
132	9×	Some((dir?, id?))
133	9×	}
134
135		impl Repo {
136	3858×	fn workspace_dir(&self, id: &WorkspaceId) -> PathBuf {
137	3858×	self.oxy.join("workspaces").join(id.to_hex())
138	3858×	}
139
140		/// Record where a workspace lives.
141	586×	pub(crate) fn register_workspace(&self, id: &WorkspaceId, path: &Path) -> Result<()> {
142	586×	let dir = self.workspace_dir(id);
143	586×	fs::create_dir_all(&dir)?;
144	586×	write_atomic(&dir.join("path"), path.to_string_lossy().as_bytes())
145	586×	}
146
147		/// The directory of a workspace, if registered.
148	4×	pub fn workspace_path(&self, id: &WorkspaceId) -> Option<PathBuf> {
149	4×	fs::read_to_string(self.workspace_dir(id).join("path"))
150	4×	.ok()
151	4×	.map(\|s\| PathBuf::from(s.trim()))
152	4×	}
153
154		/// Every workspace this repository knows about.
155	6×	pub fn workspaces(&self) -> Result<Vec<WorkspaceInfo>> {
156	6×	let view = self.view()?;
157	6×	let mut ids: BTreeSet<WorkspaceId> = view.workspaces.keys().copied().collect();
158	6×	if let Ok(rd) = fs::read_dir(self.oxy.join("workspaces")) {
159	9×	for e in rd.flatten() {
160	9×	if let Some(id) = WorkspaceId::from_hex(&e.file_name().to_string_lossy()) {
161	9×	if e.path().join("path").exists() {
162	9×	ids.insert(id);
163	9×	}
164	0×	}
165		}
166	0×	}
167	6×	let mut out = Vec::new();
168	9×	for id in ids {
169	9×	let path = if id == self.workspace {
170	6×	self.root.clone()
171		} else {
172	3×	self.workspace_path(&id)
173	3×	.unwrap_or_else(\|\| PathBuf::from("(unknown)"))
174		};
175	9×	out.push(WorkspaceInfo {
176	9×	id,
177	9×	path,
178	9×	working_copy: view.workspaces.get(&id).copied(),
179	9×	current: id == self.workspace,
180	9×	});
181		}
182	6×	Ok(out)
183	6×	}
184
185		/// Create a workspace at `dir` checked out on `heads` (default the
186		/// bookmark's), and return a `Repo` rooted there.
187		/// `bookmark` is the new workspace's current bookmark (oxygen#60), by
188		/// default this workspace's.
189	6×	pub fn workspace_add(&self, dir: &Path, heads: Option<&[ChangeHash]>) -> Result<Repo> {
190	6×	self.workspace_add_on(dir, heads, None)
191	6×	}
192
193		/// [`Repo::workspace_add`] with the new workspace on `bookmark`.
194	8×	pub fn workspace_add_on(
195	8×	&self,
196	8×	dir: &Path,
197	8×	heads: Option<&[ChangeHash]>,
198	8×	bookmark: Option<&str>,
199	8×	) -> Result<Repo> {
200	8×	if dir.exists() && fs::read_dir(dir)?.next().is_some() {
201	0×	return fail(format!("{} exists and is not empty", dir.display()));
202	8×	}
203	8×	fs::create_dir_all(dir)?;
204	8×	let dir = crate::portable::canonical(dir)?;
205	8×	if dir == self.root \|\| dir.starts_with(&self.root) \|\| self.root.starts_with(&dir) {
206	1×	return fail("a workspace cannot be inside another workspace of the same repository");
207	7×	}
208	7×	let heads = match heads {
209	2×	Some(h) => h.to_vec(),
210	5×	None => self.bookmark_heads()?,
211		};
212	7×	let id = WorkspaceId::random();
213		// On nothing, as the directory is, until the checkout: on `heads`,
214		// the checkout's first snapshot found every file of the tree
215		// deleted, rendering the whole tree to say so (195 s of a 467 s
216		// `oxy workspace add` in the VS Code history, oxygen#137).
217	7×	let wc = self.new_working_copy(Vec::new(), "");
218	7×	let wc_hash = self.store.put_change(&wc)?;
219	7×	let (op_ref, op) = self.head_op()?;
220	7×	let mut view = op.view.clone();
221	7×	view.workspaces.insert(id, wc_hash);
222	7×	self.record_op(
223	7×	&[op_ref],
224	7×	&format!("oxy workspace add {}", dir.display()),
225	7×	view,
226	0×	)?;
227	7×	self.register_workspace(&id, &dir)?;
228	7×	self.set_workspace_bookmark(&id, bookmark.unwrap_or(&self.config.bookmark))?;
229	7×	write_atomic(
230	7×	&dir.join(OXY_DIR),
231	7×	format!(
232	7×	"oxydir: {}\nworkspace: {}\n",
233	7×	self.oxy.display(),
234	7×	id.to_hex()
235	7×	)
236	7×	.as_bytes(),
237	0×	)?;
238	7×	let repo = Repo::open(&dir)?.with_home(self.keys_dir.parent().unwrap_or(&self.keys_dir));
239	7×	repo.checkout(&heads, true, "oxy workspace add (checkout)")?;
240	7×	self.copy_subrepos_into(&repo);
241	7×	Ok(repo)
242	8×	}
243
244		/// The new workspace's subrepos at their pins, from this workspace's
245		/// own copies (oxygen#61): a local clone, its remote then pointed at
246		/// the subrepo's URL, and the pin checked out, with no network unless
247		/// this copy lacks the pinned changes. A subrepo this workspace does
248		/// not have stays for `oxy submodule update --init`. Best effort.
249	7×	fn copy_subrepos_into(&self, new: &Repo) {
250	7×	let Ok(subs) = new.subrepos() else { return };
251	7×	let modules = new.modules_on_disk();
252	7×	for s in subs {
253	1×	let (src, dst) = (self.root.join(&s.path), new.root.join(&s.path));
254	1×	if dst.join(OXY_DIR).exists() \|\| dst.join(".git").exists() {
255	0×	continue;
256	1×	}
257	1×	let url = modules.entries.get(&s.path).map(\|m\| m.url.clone());
258	1×	if let Some(parent) = dst.parent() {
259	1×	let _ = fs::create_dir_all(parent);
260	1×	}
261	1×	let _ = fs::remove_dir(&dst);
262	1×	if src.join(OXY_DIR).exists() {
263	1×	match Repo::clone(&src.to_string_lossy(), &dst) {
264	1×	Ok(mut sub) => {
265	1×	if let Some(u) = &url {
266	1×	if sub.config.set("remote.origin.url", u).is_ok() {
267	1×	let _ = sub.save_config();
268	1×	}
269	0×	}
270		}
271	0×	Err(_) => continue,
272		}
273	0×	} else if src.join(".git").exists() {
274	0×	let cloned = std::process::Command::new("git")
275	0×	.args(["clone", "-q", "--local"])
276	0×	.arg(&src)
277	0×	.arg(&dst)
278	0×	.status()
279	0×	.is_ok_and(\|st\| st.success());
280	0×	if !cloned {
281	0×	continue;
282	0×	}
283	0×	if let Some(u) = &url {
284	0×	let _ = std::process::Command::new("git")
285	0×	.arg("-C")
286	0×	.arg(&dst)
287	0×	.args(["remote", "set-url", "origin", u])
288	0×	.status();
289	0×	}
290		} else {
291	0×	continue;
292		}
293	1×	let _ = new.sync_subrepo(&s.path, &s.pin, false);
294		}
295	7×	}
296
297		/// Drop a workspace from the view and registry; its files stay.
298	2×	pub fn workspace_forget(&self, id: &WorkspaceId) -> Result<()> {
299	2×	if *id == self.workspace {
300	1×	return fail("cannot forget the workspace you are in");
301	1×	}
302	1×	let (op_ref, op) = self.head_op()?;
303	1×	let mut view = op.view.clone();
304	1×	if view.workspaces.remove(id).is_none() && self.workspace_path(id).is_none() {
305	0×	return fail(format!("no workspace {}", id.short(8)));
306	1×	}
307	1×	self.record_op(
308	1×	&[op_ref],
309	1×	&format!("oxy workspace forget {}", id.short(8)),
310	1×	view,
311	0×	)?;
312	1×	let _ = fs::remove_dir_all(self.workspace_dir(id));
313	1×	Ok(())
314	2×	}
315
316		/// Take this workspace's snapshot lock (spec §12.1).
317	1618×	pub(crate) fn lock_snapshot(&self) -> Result<SnapshotLock> {
318	1618×	self.lock_working_copy()
319	1618×	}
320
321		/// Take this workspace's working-copy lock (spec §12.1), waiting up to
322		/// a minute for another process's checkout or snapshot to finish.
323	3267×	pub fn lock_working_copy(&self) -> Result<WorkingCopyLock> {
324	3267×	let dir = self.workspace_dir(&self.workspace);
325	3267×	if self.bare {
326		// No working copy to guard.
327	1×	return Ok(WorkingCopyLock {
328	1×	path: dir,
329	1×	_file: None,
330	1×	});
331	3266×	}
332	3266×	fs::create_dir_all(&dir)?;
333	3266×	let path = dir.join("lock");
334	3266×	let held = HELD.with(\|h\| {
335	3266×	let mut h = h.borrow_mut();
336	3266×	match h.get_mut(&path) {
337	1398×	Some(n) => {
338	1398×	*n += 1;
339	1398×	true
340		}
341	1868×	None => false,
342		}
343	3266×	});
344	3266×	if held {
345	1398×	return Ok(WorkingCopyLock { path, _file: None });
346	1868×	}
347	1868×	let file = FileLock::acquire_within(
348	1868×	path.clone(),
349	1868×	"another oxy process is using this working copy (a checkout or snapshot); try again when it finishes",
350	1868×	std::time::Duration::from_secs(60),
351	0×	)?;
352	1868×	HELD.with(\|h\| h.borrow_mut().insert(path.clone(), 1));
353		// Whoever held the lock may have moved the operation head: what
354		// is done under it starts from the head as it is now (oxygenhub#249).
355	1868×	self.forget_head();
356	1868×	Ok(WorkingCopyLock {
357	1868×	path,
358	1868×	_file: Some(file),
359	1868×	})
360	3267×	}
361		}

Coverage / crates/oxy-core/src/repo/workspace.rs 86.7%

Keyboard