workspace.rs 86.7%

221 of 255 lines run, 37 of 54 functions · run #335 on proposal/123 · 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 = dir.canonicalize()?;
        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();
        let wc = self.new_working_copy(heads.clone(), "");
        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	2761×	fn drop(&mut self) {
46	2761×	HELD.with(\|h\| {
47	2761×	let mut h = h.borrow_mut();
48	2761×	if let Some(n) = h.get_mut(&self.path) {
49	2760×	*n -= 1;
50	2760×	if *n == 0 {
51	1635×	h.remove(&self.path);
52	1635×	}
53	1×	}
54	2761×	});
55	2761×	}
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	130×	pub(crate) fn lock_is_stale(path: &Path) -> bool {
61	130×	let old = fs::metadata(path)
62	130×	.and_then(\|m\| m.modified())
63	130×	.map(\|t\| t.elapsed().map(\|d\| d.as_secs() > 60).unwrap_or(false))
64	130×	.unwrap_or(true);
65	130×	let proc_fs = Path::new("/proc/self").exists();
66	130×	match fs::read_to_string(path)
67	130×	.ok()
68	130×	.and_then(\|s\| s.trim().parse::<u32>().ok())
69		{
70	130×	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	130×	}
75
76		impl Drop for FileLock {
77	5157×	fn drop(&mut self) {
78	5157×	let _ = fs::remove_file(&self.path);
79	5157×	}
80		}
81
82		impl FileLock {
83		/// Wait up to about five seconds for `path`; `busy` is the error after that.
84	3522×	pub(crate) fn acquire(path: PathBuf, busy: &str) -> Result<FileLock> {
85	3522×	Self::acquire_within(path, busy, std::time::Duration::from_secs(5))
86	3522×	}
87
88		/// Wait up to `wait` for `path`; `busy` is the error after that.
89	5157×	pub(crate) fn acquire_within(
90	5157×	path: PathBuf,
91	5157×	busy: &str,
92	5157×	wait: std::time::Duration,
93	5157×	) -> Result<FileLock> {
94	5157×	let until = std::time::Instant::now() + wait;
95		loop {
96	5286×	match fs::OpenOptions::new()
97	5286×	.write(true)
98	5286×	.create_new(true)
99	5286×	.open(&path)
100		{
101	5157×	Ok(mut f) => {
102	5157×	let _ = write!(f, "{}", std::process::id());
103	5157×	return Ok(FileLock { path });
104		}
105	129×	Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
106	129×	if lock_is_stale(&path) {
107	1×	let _ = fs::remove_file(&path);
108	1×	continue;
109	128×	}
110	128×	if std::time::Instant::now() >= until {
111	0×	return fail(busy);
112	128×	}
113	128×	std::thread::sleep(std::time::Duration::from_millis(10));
114		}
115	0×	Err(e) => return Err(e.into()),
116		}
117		}
118	5157×	}
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	3276×	fn workspace_dir(&self, id: &WorkspaceId) -> PathBuf {
137	3276×	self.oxy.join("workspaces").join(id.to_hex())
138	3276×	}
139
140		/// Record where a workspace lives.
141	510×	pub(crate) fn register_workspace(&self, id: &WorkspaceId, path: &Path) -> Result<()> {
142	510×	let dir = self.workspace_dir(id);
143	510×	fs::create_dir_all(&dir)?;
144	510×	write_atomic(&dir.join("path"), path.to_string_lossy().as_bytes())
145	510×	}
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 = dir.canonicalize()?;
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	7×	let wc = self.new_working_copy(heads.clone(), "");
214	7×	let wc_hash = self.store.put_change(&wc)?;
215	7×	let (op_ref, op) = self.head_op()?;
216	7×	let mut view = op.view.clone();
217	7×	view.workspaces.insert(id, wc_hash);
218	7×	self.record_op(
219	7×	&[op_ref],
220	7×	&format!("oxy workspace add {}", dir.display()),
221	7×	view,
222	0×	)?;
223	7×	self.register_workspace(&id, &dir)?;
224	7×	self.set_workspace_bookmark(&id, bookmark.unwrap_or(&self.config.bookmark))?;
225	7×	write_atomic(
226	7×	&dir.join(OXY_DIR),
227	7×	format!(
228	7×	"oxydir: {}\nworkspace: {}\n",
229	7×	self.oxy.display(),
230	7×	id.to_hex()
231	7×	)
232	7×	.as_bytes(),
233	0×	)?;
234	7×	let repo = Repo::open(&dir)?.with_home(self.keys_dir.parent().unwrap_or(&self.keys_dir));
235	7×	repo.checkout(&heads, true, "oxy workspace add (checkout)")?;
236	7×	self.copy_subrepos_into(&repo);
237	7×	Ok(repo)
238	8×	}
239
240		/// The new workspace's subrepos at their pins, from this workspace's
241		/// own copies (oxygen#61): a local clone, its remote then pointed at
242		/// the subrepo's URL, and the pin checked out, with no network unless
243		/// this copy lacks the pinned changes. A subrepo this workspace does
244		/// not have stays for `oxy submodule update --init`. Best effort.
245	7×	fn copy_subrepos_into(&self, new: &Repo) {
246	7×	let Ok(subs) = new.subrepos() else { return };
247	7×	let modules = new.modules_on_disk();
248	7×	for s in subs {
249	1×	let (src, dst) = (self.root.join(&s.path), new.root.join(&s.path));
250	1×	if dst.join(OXY_DIR).exists() \|\| dst.join(".git").exists() {
251	0×	continue;
252	1×	}
253	1×	let url = modules.entries.get(&s.path).map(\|m\| m.url.clone());
254	1×	if let Some(parent) = dst.parent() {
255	1×	let _ = fs::create_dir_all(parent);
256	1×	}
257	1×	let _ = fs::remove_dir(&dst);
258	1×	if src.join(OXY_DIR).exists() {
259	1×	match Repo::clone(&src.to_string_lossy(), &dst) {
260	1×	Ok(mut sub) => {
261	1×	if let Some(u) = &url {
262	1×	if sub.config.set("remote.origin.url", u).is_ok() {
263	1×	let _ = sub.save_config();
264	1×	}
265	0×	}
266		}
267	0×	Err(_) => continue,
268		}
269	0×	} else if src.join(".git").exists() {
270	0×	let cloned = std::process::Command::new("git")
271	0×	.args(["clone", "-q", "--local"])
272	0×	.arg(&src)
273	0×	.arg(&dst)
274	0×	.status()
275	0×	.is_ok_and(\|st\| st.success());
276	0×	if !cloned {
277	0×	continue;
278	0×	}
279	0×	if let Some(u) = &url {
280	0×	let _ = std::process::Command::new("git")
281	0×	.arg("-C")
282	0×	.arg(&dst)
283	0×	.args(["remote", "set-url", "origin", u])
284	0×	.status();
285	0×	}
286		} else {
287	0×	continue;
288		}
289	1×	let _ = new.sync_subrepo(&s.path, &s.pin, false);
290		}
291	7×	}
292
293		/// Drop a workspace from the view and registry; its files stay.
294	2×	pub fn workspace_forget(&self, id: &WorkspaceId) -> Result<()> {
295	2×	if *id == self.workspace {
296	1×	return fail("cannot forget the workspace you are in");
297	1×	}
298	1×	let (op_ref, op) = self.head_op()?;
299	1×	let mut view = op.view.clone();
300	1×	if view.workspaces.remove(id).is_none() && self.workspace_path(id).is_none() {
301	0×	return fail(format!("no workspace {}", id.short(8)));
302	1×	}
303	1×	self.record_op(
304	1×	&[op_ref],
305	1×	&format!("oxy workspace forget {}", id.short(8)),
306	1×	view,
307	0×	)?;
308	1×	let _ = fs::remove_dir_all(self.workspace_dir(id));
309	1×	Ok(())
310	2×	}
311
312		/// Take this workspace's snapshot lock (spec §12.1).
313	1343×	pub(crate) fn lock_snapshot(&self) -> Result<SnapshotLock> {
314	1343×	self.lock_working_copy()
315	1343×	}
316
317		/// Take this workspace's working-copy lock (spec §12.1), waiting up to
318		/// a minute for another process's checkout or snapshot to finish.
319	2761×	pub fn lock_working_copy(&self) -> Result<WorkingCopyLock> {
320	2761×	let dir = self.workspace_dir(&self.workspace);
321	2761×	if self.bare {
322		// No working copy to guard.
323	1×	return Ok(WorkingCopyLock {
324	1×	path: dir,
325	1×	_file: None,
326	1×	});
327	2760×	}
328	2760×	fs::create_dir_all(&dir)?;
329	2760×	let path = dir.join("lock");
330	2760×	let held = HELD.with(\|h\| {
331	2760×	let mut h = h.borrow_mut();
332	2760×	match h.get_mut(&path) {
333	1125×	Some(n) => {
334	1125×	*n += 1;
335	1125×	true
336		}
337	1635×	None => false,
338		}
339	2760×	});
340	2760×	if held {
341	1125×	return Ok(WorkingCopyLock { path, _file: None });
342	1635×	}
343	1635×	let file = FileLock::acquire_within(
344	1635×	path.clone(),
345	1635×	"another oxy process is using this working copy (a checkout or snapshot); try again when it finishes",
346	1635×	std::time::Duration::from_secs(60),
347	0×	)?;
348	1635×	HELD.with(\|h\| h.borrow_mut().insert(path.clone(), 1));
349		// Whoever held the lock may have moved the operation head: what
350		// is done under it starts from the head as it is now (oxygenhub#249).
351	1635×	self.forget_head();
352	1635×	Ok(WorkingCopyLock {
353	1635×	path,
354	1635×	_file: Some(file),
355	1635×	})
356	2761×	}
357		}

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

Keyboard