This is an archive of the discontinued Mercurial Phabricator instance.

Status	Author	Revision
Closed	mbthomas	D1528 treedirstate: prevent interference with other dirstate implementations
Closed	mbthomas	D1512 treedirstate: de-genericize Dirstate
Closed	mbthomas	D1510 treedirstate: extract serialization methods to separate module
Closed	mbthomas	D1490 treedirstate: add integration tests
Closed	mbthomas	D1434 treedirstate: add configuration options
Closed	mbthomas	D1412 setup: build treedirstate and rusttreedirstate packages
Closed	mbthomas	D1411 distutils_rust: add distutils extension to compile Rust extension modules
Closed	mbthomas	D1410 perftweaks: support treedirstate maps
Closed	mbthomas	D1409 treedirstate: implement casefolding maps for case insensitive filesystems
Closed	mbthomas	D1408 treedirstate: use vlqencoding for numbers
Closed	mbthomas	D1407 treedirstate: auto-repack treedirstate once it reaches 3x its original size
Closed	mbthomas	D1406 treedirstate: implement efficient case collision detection
Closed	mbthomas	D1405 treedirstate: allow absent non-normal sets
Closed	mbthomas	D1404 treedirstate: clear ambiguous times when writing the dirstate
Closed	mbthomas	D1403 treedirstate: better iteration using visitor pattern
Closed	mbthomas	D1402 treedirstate: cache dirstate data when iterating all files
Closed	mbthomas	D1401 treedirstate: add Python linkage
Closed	mbthomas	D1400 treedirstate: add Dirstate
Closed	mbthomas	D1399 treedirstate: add Tree
Closed	mbthomas	D1398 treedirstate: add FileStore
Closed	mbthomas	D1397 treedirstate: add Store and StoreView traits
Closed	mbthomas	D1396 treedirstate: add vecmap implementation
Closed	mbthomas	D1395 treedirstate: create empty Rust project

Diff 3849

rust/treedirstate/src/dirstate.rs

	// Copyright Facebook, Inc. 2017			// Copyright Facebook, Inc. 2017
	//! Directory State.			//! Directory State.

	use errors::*;			use errors::*;
				use filestate::FileState;
	use filestore::FileStore;			use filestore::FileStore;
	use serialization::Serializable;			use serialization::Serializable;
	use std::io::Cursor;			use std::io::Cursor;
	use std::path::Path;			use std::path::Path;
	use store::{BlockId, NullStore, Store, StoreView};			use store::{BlockId, NullStore, Store, StoreView};
	use tree::{Key, KeyRef, Tree};			use tree::{Key, KeyRef, Tree};

	/// Selected backend implementation for the dirstate.			/// Selected backend implementation for the dirstate.
	Backend::Empty(ref _null) => None,			Backend::Empty(ref _null) => None,
	Backend::File(ref file) => Some(file.position()),			Backend::File(ref file) => Some(file.position()),
	}			}
	}			}
	}			}

	/// A dirstate object. This contains the state of all files in the dirstate, stored in tree			/// A dirstate object. This contains the state of all files in the dirstate, stored in tree
	/// structures, and backed by an append-only store on disk.			/// structures, and backed by an append-only store on disk.
	pub struct Dirstate<T> {			pub struct Dirstate {
	/// The store currently in use by the Dirstate.			/// The store currently in use by the Dirstate.
	store: Backend,			store: Backend,

	/// The tree of tracked files.			/// The tree of tracked files.
	tracked: Tree<T>,			tracked: Tree<FileState>,

	/// The tree of removed files.			/// The tree of removed files.
	removed: Tree<T>,			removed: Tree<FileState>,

	/// The ID of the root block.			/// The ID of the root block.
	root_id: Option<BlockId>,			root_id: Option<BlockId>,
	}			}

	/// Representation of the root of a dirstate tree that can be serialized to disk.			/// Representation of the root of a dirstate tree that can be serialized to disk.
	pub(crate) struct DirstateRoot {			pub(crate) struct DirstateRoot {
	pub(crate) tracked_root_id: BlockId,			pub(crate) tracked_root_id: BlockId,
	pub(crate) tracked_file_count: u32,			pub(crate) tracked_file_count: u32,
	pub(crate) removed_root_id: BlockId,			pub(crate) removed_root_id: BlockId,
	pub(crate) removed_file_count: u32,			pub(crate) removed_file_count: u32,
	}			}

	impl<T: Serializable + Clone> Dirstate<T> {			impl Dirstate {
	/// Create a new, empty dirstate, with no backend store.			/// Create a new, empty dirstate, with no backend store.
	pub fn new() -> Dirstate<T> {			pub fn new() -> Dirstate {
	Dirstate {			Dirstate {
	store: Backend::Empty(NullStore::new()),			store: Backend::Empty(NullStore::new()),
	tracked: Tree::new(),			tracked: Tree::new(),
	removed: Tree::new(),			removed: Tree::new(),
	root_id: None,			root_id: None,
	}			}
	}			}

	}			}

	/// Returns the current append offset for the file store.			/// Returns the current append offset for the file store.
	pub fn store_offset(&self) -> Option<u64> {			pub fn store_offset(&self) -> Option<u64> {
	self.store.offset()			self.store.offset()
	}			}

	/// Add or update a file entry in the dirstate.			/// Add or update a file entry in the dirstate.
	pub fn add_file(&mut self, name: KeyRef, state: &T) -> Result<()> {			pub fn add_file(&mut self, name: KeyRef, state: &FileState) -> Result<()> {
	let store = self.store.store_view();			let store = self.store.store_view();
	self.removed.remove(store, name)?;			self.removed.remove(store, name)?;
	self.tracked.add(store, name, state)?;			self.tracked.add(store, name, state)?;
	Ok(())			Ok(())
	}			}

	/// Mark a file as removed in the dirstate.			/// Mark a file as removed in the dirstate.
	pub fn remove_file(&mut self, name: KeyRef, state: &T) -> Result<()> {			pub fn remove_file(&mut self, name: KeyRef, state: &FileState) -> Result<()> {
	let store = self.store.store_view();			let store = self.store.store_view();
	self.tracked.remove(store, name)?;			self.tracked.remove(store, name)?;
	self.removed.add(store, name, state)?;			self.removed.add(store, name, state)?;
	Ok(())			Ok(())
	}			}

	/// Drop a file from the dirstate.			/// Drop a file from the dirstate.
	pub fn drop_file(&mut self, name: KeyRef) -> Result<bool> {			pub fn drop_file(&mut self, name: KeyRef) -> Result<bool> {
	let store = self.store.store_view();			let store = self.store.store_view();
	let tracked = self.tracked.remove(store, name)?;			let tracked = self.tracked.remove(store, name)?;
	let removed = self.removed.remove(store, name)?;			let removed = self.removed.remove(store, name)?;
	Ok(tracked \|\| removed)			Ok(tracked \|\| removed)
	}			}

	pub fn tracked_count(&self) -> u32 {			pub fn tracked_count(&self) -> u32 {
	self.tracked.file_count()			self.tracked.file_count()
	}			}

	pub fn removed_count(&self) -> u32 {			pub fn removed_count(&self) -> u32 {
	self.removed.file_count()			self.removed.file_count()
	}			}

	/// Get an entry from the tracked tree.			/// Get an entry from the tracked tree.
	pub fn get_tracked<'a>(&'a mut self, name: KeyRef) -> Result<Option<&'a T>> {			pub fn get_tracked<'a>(&'a mut self, name: KeyRef) -> Result<Option<&'a FileState>> {
	self.tracked.get(self.store.store_view(), name)			self.tracked.get(self.store.store_view(), name)
	}			}

	pub fn get_tracked_filtered_key<F>(			pub fn get_tracked_filtered_key<F>(
	&mut self,			&mut self,
	name: KeyRef,			name: KeyRef,
	filter: &mut F,			filter: &mut F,
	) -> Result<Option<Key>>			) -> Result<Option<Key>>
	where			where
	F: FnMut(KeyRef) -> Result<Key>,			F: FnMut(KeyRef) -> Result<Key>,
	{			{
	self.tracked			self.tracked
	.get_filtered_key(self.store.store_view(), name, filter)			.get_filtered_key(self.store.store_view(), name, filter)
	}			}

	/// Visit all tracked files with a visitor.			/// Visit all tracked files with a visitor.
	pub fn visit_tracked<F>(&mut self, visitor: &mut F) -> Result<()>			pub fn visit_tracked<F>(&mut self, visitor: &mut F) -> Result<()>
	where			where
	F: FnMut(&Vec<KeyRef>, &mut T) -> Result<()>,			F: FnMut(&Vec<KeyRef>, &mut FileState) -> Result<()>,
	{			{
	self.store.cache()?;			self.store.cache()?;
	self.tracked.visit(self.store.store_view(), visitor)			self.tracked.visit(self.store.store_view(), visitor)
	}			}

	/// Visit all tracked files in changed nodes with a visitor.			/// Visit all tracked files in changed nodes with a visitor.
	pub fn visit_changed_tracked<F>(&mut self, visitor: &mut F) -> Result<()>			pub fn visit_changed_tracked<F>(&mut self, visitor: &mut F) -> Result<()>
	where			where
	F: FnMut(&Vec<KeyRef>, &mut T) -> Result<()>,			F: FnMut(&Vec<KeyRef>, &mut FileState) -> Result<()>,
	{			{
	self.store.cache()?;			self.store.cache()?;
	self.tracked.visit_changed(self.store.store_view(), visitor)			self.tracked.visit_changed(self.store.store_view(), visitor)
	}			}

	/// Get the name and state of the first file in the tracked tree.			/// Get the name and state of the first file in the tracked tree.
	pub fn get_first_tracked<'a>(&'a mut self) -> Result<Option<(Key, &'a T)>> {			pub fn get_first_tracked<'a>(&'a mut self) -> Result<Option<(Key, &'a FileState)>> {
	self.store.cache()?;			self.store.cache()?;
	self.tracked.get_first(self.store.store_view())			self.tracked.get_first(self.store.store_view())
	}			}

	/// Get the name and state of the next file in the tracked tree after the named file.			/// Get the name and state of the next file in the tracked tree after the named file.
	pub fn get_next_tracked<'a>(&'a mut self, name: KeyRef) -> Result<Option<(Key, &'a T)>> {			pub fn get_next_tracked<'a>(
				&'a mut self,
				name: KeyRef,
				) -> Result<Option<(Key, &'a FileState)>> {
	self.tracked.get_next(self.store.store_view(), name)			self.tracked.get_next(self.store.store_view(), name)
	}			}

	pub fn has_tracked_dir(&mut self, name: KeyRef) -> Result<bool> {			pub fn has_tracked_dir(&mut self, name: KeyRef) -> Result<bool> {
	self.tracked.has_dir(self.store.store_view(), name)			self.tracked.has_dir(self.store.store_view(), name)
	}			}

	/// Get an entry from the removed tree.			/// Get an entry from the removed tree.
	pub fn get_removed<'a>(&'a mut self, name: KeyRef) -> Result<Option<&'a T>> {			pub fn get_removed<'a>(&'a mut self, name: KeyRef) -> Result<Option<&'a FileState>> {
	self.removed.get(self.store.store_view(), name)			self.removed.get(self.store.store_view(), name)
	}			}

	/// Visit all removed files with a visitor.			/// Visit all removed files with a visitor.
	pub fn visit_removed<F>(&mut self, visitor: &mut F) -> Result<()>			pub fn visit_removed<F>(&mut self, visitor: &mut F) -> Result<()>
	where			where
	F: FnMut(&Vec<KeyRef>, &mut T) -> Result<()>,			F: FnMut(&Vec<KeyRef>, &mut FileState) -> Result<()>,
	{			{
	self.removed.visit(self.store.store_view(), visitor)			self.removed.visit(self.store.store_view(), visitor)
	}			}

	/// Get the name and state of the first file in the removed tree.			/// Get the name and state of the first file in the removed tree.
	pub fn get_first_removed<'a>(&'a mut self) -> Result<Option<(Key, &'a T)>> {			pub fn get_first_removed<'a>(&'a mut self) -> Result<Option<(Key, &'a FileState)>> {
	self.removed.get_first(self.store.store_view())			self.removed.get_first(self.store.store_view())
	}			}

	/// Get the name and state of the next file in the removed tree after the named file.			/// Get the name and state of the next file in the removed tree after the named file.
	pub fn get_next_removed<'a>(&'a mut self, name: KeyRef) -> Result<Option<(Key, &'a T)>> {			pub fn get_next_removed<'a>(
				&'a mut self,
				name: KeyRef,
				) -> Result<Option<(Key, &'a FileState)>> {
	self.removed.get_next(self.store.store_view(), name)			self.removed.get_next(self.store.store_view(), name)
	}			}

	pub fn has_removed_dir(&mut self, name: KeyRef) -> Result<bool> {			pub fn has_removed_dir(&mut self, name: KeyRef) -> Result<bool> {
	self.removed.has_dir(self.store.store_view(), name)			self.removed.has_dir(self.store.store_view(), name)
	}			}

	pub fn clear_filtered_keys(&mut self) {			pub fn clear_filtered_keys(&mut self) {
	self.tracked.clear_filtered_keys();			self.tracked.clear_filtered_keys();
	}			}
	}			}

	#[cfg(test)]			#[cfg(test)]
	mod tests {			mod tests {
	use dirstate::Dirstate;			use dirstate::Dirstate;
	use tempdir::TempDir;			use tempdir::TempDir;
	use std::io::{Read, Write};			use filestate::FileState;
	use byteorder::{ReadBytesExt, WriteBytesExt};
	use serialization::Serializable;
	use errors::*;

	#[derive(PartialEq, Clone, Debug)]
	struct State(char);

	impl Serializable for State {			fn make_state(state: u8) -> FileState {
	fn serialize(&self, w: &mut Write) -> Result<()> {			FileState::new(state, 0, 0, 0)
	w.write_u8(self.0 as u8)?;
	Ok(())
	}

	fn deserialize(r: &mut Read) -> Result<State> {
	Ok(State(r.read_u8()? as char))
	}
	}			}

	#[test]			#[test]
	fn goodpath() {			fn goodpath() {
	let dir = TempDir::new("dirstate_test").expect("create temp dir");			let dir = TempDir::new("dirstate_test").expect("create temp dir");
	let p = dir.path().join("store");			let p = dir.path().join("store");
	let mut ds = Dirstate::<State>::new();			let mut ds = Dirstate::new();
	ds.write_full(&p).expect("can write full empty dirstate");			ds.write_full(&p).expect("can write full empty dirstate");
	ds.add_file(b"dirA/file1", &State('n')).expect("can add");			ds.add_file(b"dirA/file1", &make_state(b'n'))
	ds.remove_file(b"dirA/file2", &State('r'))			.expect("can add");
				ds.remove_file(b"dirA/file2", &make_state(b'r'))
	.expect("can remove");			.expect("can remove");
	ds.write_delta().expect("can write delta");			ds.write_delta().expect("can write delta");
	ds.add_file(b"dirA/file2", &State('n')).expect("can add");			ds.add_file(b"dirA/file2", &make_state(b'n'))
	ds.remove_file(b"dirA/file1", &State('r'))			.expect("can add");
				ds.remove_file(b"dirA/file1", &make_state(b'r'))
	.expect("can remove");			.expect("can remove");
	ds.write_delta().expect("can write delta");			ds.write_delta().expect("can write delta");
	let ds_root = ds.root_id().unwrap();			let ds_root = ds.root_id().unwrap();
	drop(ds);			drop(ds);
	let mut ds2 = Dirstate::<State>::new();			let mut ds2 = Dirstate::new();
	ds2.open(&p, ds_root).expect("can re-open");			ds2.open(&p, ds_root).expect("can re-open");
	ds2.add_file(b"dirB/file3", &State('m')).expect("can add");			ds2.add_file(b"dirB/file3", &make_state(b'm'))
	ds2.remove_file(b"dirC/file4", &State('r'))			.expect("can add");
				ds2.remove_file(b"dirC/file4", &make_state(b'r'))
	.expect("can remove");			.expect("can remove");
	assert_eq!(ds2.get_tracked(b"dirA/file1").expect("can get"), None);			assert_eq!(ds2.get_tracked(b"dirA/file1").expect("can get"), None);
	assert_eq!(			assert_eq!(
	ds2.get_tracked(b"dirA/file2").expect("can get"),			ds2.get_tracked(b"dirA/file2").expect("can get"),
	Some(&State('n'))			Some(&make_state(b'n'))
	);			);
	assert_eq!(			assert_eq!(
	ds2.get_removed(b"dirA/file1").expect("can get"),			ds2.get_removed(b"dirA/file1").expect("can get"),
	Some(&State('r'))			Some(&make_state(b'r'))
	);			);
	assert_eq!(ds2.get_removed(b"dirA/file2").expect("can get"), None);			assert_eq!(ds2.get_removed(b"dirA/file2").expect("can get"), None);
	assert_eq!(ds2.tracked_count(), 2);			assert_eq!(ds2.tracked_count(), 2);
	assert_eq!(ds2.removed_count(), 2);			assert_eq!(ds2.removed_count(), 2);
	ds2.drop_file(b"dirA/file1").expect("can drop");			ds2.drop_file(b"dirA/file1").expect("can drop");
	ds2.drop_file(b"dirA/file2").expect("can drop");			ds2.drop_file(b"dirA/file2").expect("can drop");
	ds2.write_delta().expect("can write delta");			ds2.write_delta().expect("can write delta");
	assert_eq!(ds2.tracked_count(), 1);			assert_eq!(ds2.tracked_count(), 1);
	assert_eq!(ds2.removed_count(), 1);			assert_eq!(ds2.removed_count(), 1);
	ds2.clear();			ds2.clear();
	ds2.write_delta().expect("can write delta");			ds2.write_delta().expect("can write delta");
	assert_eq!(ds2.tracked_count(), 0);			assert_eq!(ds2.tracked_count(), 0);
	assert_eq!(ds2.removed_count(), 0);			assert_eq!(ds2.removed_count(), 0);
	}			}
	}			}

rust/treedirstate/src/python.rs

	let s = e.instance(py)			let s = e.instance(py)
	.extract::<String>(py)			.extract::<String>(py)
	.unwrap_or_else(\|_e\| "unknown exception".to_string());			.unwrap_or_else(\|_e\| "unknown exception".to_string());
	ErrorKind::CallbackError(s)			ErrorKind::CallbackError(s)
	}			}

	py_class!(class treedirstatemap \|py\| {			py_class!(class treedirstatemap \|py\| {
	data repodir: PathBuf;			data repodir: PathBuf;
	data dirstate: RefCell<Dirstate<FileState>>;			data dirstate: RefCell<Dirstate>;
	data casefolderid: RefCell<Option<usize>>;			data casefolderid: RefCell<Option<usize>>;

	def __new__(			def __new__(
	_cls,			_cls,
	_ui: &PyObject,			_ui: &PyObject,
	opener: &PyObject			opener: &PyObject
	) -> PyResult<treedirstatemap> {			) -> PyResult<treedirstatemap> {
	let repodir = opener.getattr(py, "base")?.extract::<String>(py)?;			let repodir = opener.getattr(py, "base")?.extract::<String>(py)?;

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	3849		Nov 24 2017, 3:19 PM	★	★
Diff 2	3945	rFBHGX470d44a31825b0d889b408ea3a6915eefd47a99a	Nov 28 2017, 7:51 AM	★	★

This is an archive of the discontinued Mercurial Phabricator instance.

treedirstate: de-genericize DirstateClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 3849

rust/treedirstate/src/dirstate.rs

rust/treedirstate/src/python.rs

treedirstate: de-genericize Dirstate
ClosedPublic

Revision Contents
Changeset List