treedirstate/__init__.py
601	The cleanup logic does not look that expensive. Maybe it could be done as a post close hook of a transaction. At that time the wlock is still taken so you don't need to take another wlock (which is expensive for read-only commands).

treedirstate/__init__.py
601	It only runs if the dirstate has been modified (based on `_repacked` or `_extended` being set), so read-only commands won't trigger a repack. I based this on what infinitepush backupcommand does at @stash's recommendation. Infinitepush used to use a transaction close hook, but it caused problems for commands that contain many transactions (e.g. `histedit`). I think it's a good idea to keep to one technique, too. What do you think?

treedirstate/__init__.py
601	Good point about histedit. The use of a separate wlock could potentially block the command unnecessarily. A transaction hook would avoid the lock issue and save a few ms on commands with a single transaction. Infinitepush backup needs to be fired at the end of the last write operation, but this cleanup does not have to. To avoid running cleanups multiple times, I think it could be done by having a per-process state.

treedirstate/__init__.py
516	I'd doc comment some of these, to make it clear what it's cleaning up.
601	Could we wrap repo.close() instead? I also dislike wrapping runcommand and it'd be nice if we could start treating repo.close() as an actual repo destructor.

treedirstate/__init__.py
601	I'll change to wrapping `repo.close()`. We still need to get the wlock separately, but cleanup happens rarely, so this should be ok.

treedirstate/__init__.py
393	As with `treedirstate_enabled`, I will update this to use `ui.log` and `sampling`.

treedirstate/__init__.py
526	If the file system is not writable, this will throw an exception. We probably don't want cleanup logic to cause commands on readonly filesystems to break. Probably always a good test candidate.

treedirstate/__init__.py
526	Aside from `debugtreedirstate cleanup`, we only ever cleanup when we've written to the dirstate already, which means it really ought to be possible to write here. That being said, I don't mind adding some belt-and-braces handling. Should I just ignore all exceptions that come out of cleanup, or are there specific ones?

treedirstate/__init__.py
526	From the comment in wrapclose, I assumed cleanup was run on 1% of commands that read the dirstate as well? Maybe that big if statement in the wrapclose finally needs to be cleaned up to make it clearer when it runs? As for exceptions, usually IOError and OSError, but since this is the Lock class it might throw something special as well.

treedirstate/__init__.py
526	I think it throws Abort. I'll clean up the if statement and the comments to make it clear, but I think it should be ok to fail here if we make it this far and the repo is read-only. That shouldn't have happened, and I'd like to know that it did.

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	3487		Nov 14 2017, 12:39 PM	★	★
Diff 2	3604		Nov 17 2017, 9:45 AM	★	★
Diff 3	3659		Nov 20 2017, 12:21 PM	★	★
Diff 4	3734		Nov 21 2017, 1:35 PM	★	★
Diff 5	3775		Nov 22 2017, 1:14 PM	★	★
Diff 6	3828		Nov 24 2017, 11:53 AM	★	★
Diff 7	3845		Nov 24 2017, 3:18 PM	★	★
Diff 8	3869		Nov 27 2017, 8:00 AM	★	★
Diff 9	3888		Nov 27 2017, 4:32 PM	★	★
Diff 10	3936	rFBHGX24df03a54d5d1c1cc573478bdb88fde479675d1d	Nov 28 2017, 7:51 AM	★	★

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 3775

rust/treedirstate/src/dirstate.rs

	}			}

	pub fn cache(&mut self) -> Result<()> {			pub fn cache(&mut self) -> Result<()> {
	match *self {			match *self {
	Backend::Empty(ref _null) => Ok(()),			Backend::Empty(ref _null) => Ok(()),
	Backend::File(ref mut file) => file.cache(),			Backend::File(ref mut file) => file.cache(),
	}			}
	}			}

				pub fn offset(&self) -> Option<u64> {
				match *self {
				Backend::Empty(ref _null) => None,
				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<T> {
	/// The store currently in use by the Dirstate.			/// The store currently in use by the Dirstate.
	store: Backend,			store: Backend,

	self.removed.clear();			self.removed.clear();
	}			}

	/// Returns the ID of the root block.			/// Returns the ID of the root block.
	pub fn root_id(&self) -> Option<BlockId> {			pub fn root_id(&self) -> Option<BlockId> {
	self.root_id			self.root_id
	}			}

				/// Returns the current append offset for the file store.
				pub fn store_offset(&self) -> Option<u64> {
				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: &T) -> 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(())
	}			}

rust/treedirstate/src/filestore.rs

	}			}
	file.get_mut().read_exact(buffer.as_mut_slice())?;			file.get_mut().read_exact(buffer.as_mut_slice())?;
	file.seek(SeekFrom::Start(self.position))?;			file.seek(SeekFrom::Start(self.position))?;
	*self.at_end.get_mut() = true;			*self.at_end.get_mut() = true;
	self.cache = Some(buffer);			self.cache = Some(buffer);
	}			}
	Ok(())			Ok(())
	}			}

				pub fn position(&self) -> u64 {
				self.position
				}
	}			}

	impl Store for FileStore {			impl Store for FileStore {
	fn append(&mut self, data: &[u8]) -> Result<BlockId> {			fn append(&mut self, data: &[u8]) -> Result<BlockId> {
	if self.read_only {			if self.read_only {
	bail!(ErrorKind::ReadOnlyStore);			bail!(ErrorKind::ReadOnlyStore);
	}			}
	let id = BlockId(self.position);			let id = BlockId(self.position);

rust/treedirstate/src/python.rs

	}			}
	Ok(())			Ok(())
	};			};
	map_pyerr!(py, dirstate.visit_changed_tracked(&mut filter), exc::IOError)?;			map_pyerr!(py, dirstate.visit_changed_tracked(&mut filter), exc::IOError)?;
	map_pyerr!(py, dirstate.write_delta(), exc::IOError)?;			map_pyerr!(py, dirstate.write_delta(), exc::IOError)?;
	Ok(None)			Ok(None)
	}			}

				def storeoffset(&self) -> PyResult<u64> {
				let dirstate = self.dirstate(py).borrow();
				let offset = dirstate.store_offset();
				Ok(offset.unwrap_or(0))
				}

	def filecount(&self) -> PyResult<usize> {			def filecount(&self) -> PyResult<usize> {
	let dirstate = self.dirstate(py).borrow();			let dirstate = self.dirstate(py).borrow();
	Ok((dirstate.tracked_count() + dirstate.removed_count()) as usize)			Ok((dirstate.tracked_count() + dirstate.removed_count()) as usize)
	}			}

	def hastrackedfile(&self, filename: PyObject) -> PyResult<bool> {			def hastrackedfile(&self, filename: PyObject) -> PyResult<bool> {
	let mut dirstate = self.dirstate(py).borrow_mut();			let mut dirstate = self.dirstate(py).borrow_mut();
	let filename = filename.extract::<PyBytes>(py)?;			let filename = filename.extract::<PyBytes>(py)?;

treedirstate/init.py

	scmutil,			scmutil,
	txnutil,			txnutil,
	util,			util,
	)			)
	from mercurial.i18n import _			from mercurial.i18n import _
	import errno			import errno
	import heapq			import heapq
	import itertools			import itertools
				import os
				import random
	import struct			import struct
				import string

	from .rusttreedirstate import RustDirstateMap			from .rusttreedirstate import RustDirstateMap

	dirstateheader = b'########################treedirstate####'			dirstateheader = b'########################treedirstate####'
	treedirstateversion = 1			treedirstateversion = 1
				treefileprefix = 'dirstate.tree.'
	useinnewrepos = True			useinnewrepos = True

	# Sentinel length value for when a nonnormalset or otherparentset is absent.			# Sentinel length value for when a nonnormalset or otherparentset is absent.
	setabsent = 0xffffffff			setabsent = 0xffffffff

				# Minimum size the treedirstate file can be before auto-repacking.
				minrepackthreshold = 1024 * 1024

				# Number of times the treedirstate file can grow by, compared to its initial
				# size, before auto-repacking.
				repackfactor = 3

	class _reader(object):			class _reader(object):
	def __init__(self, data, offset):			def __init__(self, data, offset):
	self.data = data			self.data = data
	self.offset = offset			self.offset = offset

	def readuint(self):			def readuint(self):
	v = struct.unpack(">L", self.data[self.offset:self.offset + 4])			v = struct.unpack(">L", self.data[self.offset:self.offset + 4])
	self.offset += 4			self.offset += 4

	self._filename = 'dirstate'			self._filename = 'dirstate'
	self._rmap = RustDirstateMap(ui, opener)			self._rmap = RustDirstateMap(ui, opener)
	self._treeid = None			self._treeid = None
	self._parents = None			self._parents = None
	self._dirtyparents = False			self._dirtyparents = False
	self._nonnormalset = set()			self._nonnormalset = set()
	self._otherparentset = set()			self._otherparentset = set()
				self._packedsize = 0

	if importmap is not None:			if importmap is not None:
	self._rmap.importmap(importmap)			self._rmap.importmap(importmap)
	self._parents = importmap._parents			self._parents = importmap._parents
	self._nonnormalset = importmap.nonnormalset			self._nonnormalset = importmap.nonnormalset
	self._otherparentset = importmap.otherparentset			self._otherparentset = importmap.otherparentset
	self.copymap = importmap.copymap			self.copymap = importmap.copymap
	else:			else:

	version = r.readuint()			version = r.readuint()
	if version != treedirstateversion:			if version != treedirstateversion:
	raise error.Abort(_('unsupported treedirstate version: %s')			raise error.Abort(_('unsupported treedirstate version: %s')
	% version)			% version)

	self._treeid = r.readstr()			self._treeid = r.readstr()
	rootid = r.readuint()			rootid = r.readuint()
	self._rmap.read('dirstate.tree.000', rootid)			self._packedsize = r.readuint()
				self._rmap.read(treefileprefix + self._treeid, rootid)
	clen = r.readuint()			clen = r.readuint()
	copymap = {}			copymap = {}
	for _i in range(clen):			for _i in range(clen):
	k = r.readstr()			k = r.readstr()
	v = r.readstr()			v = r.readstr()
	copymap[k] = v			copymap[k] = v

	def readset():			def readset():

	def write(self, st, now):			def write(self, st, now):
	"""Write the dirstate to the filehandle st."""			"""Write the dirstate to the filehandle st."""
	if self._nonnormalset is not None:			if self._nonnormalset is not None:
	nonnormadd = self._nonnormalset.add			nonnormadd = self._nonnormalset.add
	else:			else:
	def nonnormadd(f):			def nonnormadd(f):
	pass			pass
				repackthreshold = max(self._packedsize * repackfactor,
				minrepackthreshold)
				if self._rmap.storeoffset() > repackthreshold:
				self._ui.note(_("auto-repacking treedirstate\n"))
				self._ui.setconfig('treedirstate', 'repacking', True)
				mbthomasAuthorUnsubmitted Not Done As with `treedirstate_enabled`, I will update this to use `ui.log` and `sampling`. mbthomas: As with `treedirstate_enabled`, I will update this to use `ui.log` and `sampling`.
				self._repacked = True
				self._treeid = None
				else:
				self._extended = True
	if self._treeid is None:			if self._treeid is None:
	self._treeid = '000'			self._treeid = newtree(self._opener)
	self._rmap.write('dirstate.tree.000', now, nonnormadd)			self._rmap.write(treefileprefix + self._treeid, now, nonnormadd)
				self._packedsize = self._rmap.storeoffset()
	else:			else:
	self._rmap.writedelta(now, nonnormadd)			self._rmap.writedelta(now, nonnormadd)
	st.write(self._genrootdata())			st.write(self._genrootdata())
	st.close()			st.close()
	self._dirtyparents = False			self._dirtyparents = False

	def writeflat(self):			def writeflat(self):
	st = self._opener("dirstate", "w", atomictemp=True, checkambig=True)			st = self._opener("dirstate", "w", atomictemp=True, checkambig=True)
	w.buffer.write(self._parents[1])			w.buffer.write(self._parents[1])
	else:			else:
	w.buffer.write(node.nullid)			w.buffer.write(node.nullid)
	w.buffer.write(node.nullid)			w.buffer.write(node.nullid)
	w.buffer.write(dirstateheader)			w.buffer.write(dirstateheader)
	w.writeuint(treedirstateversion)			w.writeuint(treedirstateversion)
	w.writestr(self._treeid)			w.writestr(self._treeid)
	w.writeuint(self._rmap.rootid())			w.writeuint(self._rmap.rootid())
				w.writeuint(self._packedsize)
	w.writeuint(len(self.copymap))			w.writeuint(len(self.copymap))
	for k, v in self.copymap.iteritems():			for k, v in self.copymap.iteritems():
	w.writestr(k)			w.writestr(k)
	w.writestr(v)			w.writestr(v)

	setthreshold = max(1000, self._rmap.filecount() / 3)			setthreshold = max(1000, self._rmap.filecount() / 3)

	def writeset(s):			def writeset(s):
	writeset(self._otherparentset)			writeset(self._otherparentset)

	return w.buffer.getvalue()			return w.buffer.getvalue()

	def istreedirstate(repo):			def istreedirstate(repo):
	return (util.safehasattr(repo, 'requirements') and			return (util.safehasattr(repo, 'requirements') and
	'treedirstate' in repo.requirements)			'treedirstate' in repo.requirements)

				def newtree(opener):
				while True:
				treeid = ''.join([random.choice(string.digits) for _c in range(8)])
				if not opener.exists(treefileprefix + treeid):
				return treeid

				def gettreeid(opener, dirstatefile):
				# The treeid is located within the first 128 bytes.
				data = opener(dirstatefile).read(128)
				if data[40:80] != dirstateheader:
				return None
				r = _reader(data, 80)
				version = r.readuint()
				if version != treedirstateversion:
				return None
				return r.readstr()

	def upgrade(ui, repo):			def upgrade(ui, repo):
	if istreedirstate(repo):			if istreedirstate(repo):
	raise error.Abort('repo already has treedirstate')			raise error.Abort('repo already has treedirstate')
	wlock = repo.wlock()			wlock = repo.wlock()
	try:			try:
	newmap = treedirstatemap(ui, repo.dirstate._opener, repo.root,			newmap = treedirstatemap(ui, repo.dirstate._opener, repo.root,
	importmap=repo.dirstate._map)			importmap=repo.dirstate._map)
	f = repo.dirstate._opener('dirstate', 'w')			f = repo.dirstate._opener('dirstate', 'w')
	try:			try:
	repo.dirstate._map.writeflat()			repo.dirstate._map.writeflat()
	repo.requirements.remove('treedirstate')			repo.requirements.remove('treedirstate')
	repo._writerequirements()			repo._writerequirements()
	del repo.dirstate			del repo.dirstate
	finally:			finally:
	wlock.release()			wlock.release()

				def repack(ui, repo):
				if not istreedirstate(repo):
				ui.note(_("not repacking because repo does not have treedirstate"))
				return
				with repo.wlock():
				repo.dirstate._map._treeid = None
				repo.dirstate._dirty = True

				dirstatefiles = [
				'dirstate',
				'dirstate.pending',
				'undo.dirstate',
				'undo.backup.dirstate',
				]

				def cleanup(ui, repo):
				durhamUnsubmitted Not Done I'd doc comment some of these, to make it clear what it's cleaning up. durham: I'd doc comment some of these, to make it clear what it's cleaning up.
				"""Clean up old tree files.

				When repacking, we write out the tree data to a new file. This allows us
				to rollback transactions without fear of losing dirstate information, as
				the old dirstate file points at the old tree file.

				This leaves old tree files lying around. We must periodically clean up
				any tree files that are not referred to by any of the dirstate files.
				"""
				with repo.wlock():
				durhamUnsubmitted Not Done If the file system is not writable, this will throw an exception. We probably don't want cleanup logic to cause commands on readonly filesystems to break. Probably always a good test candidate. durham: If the file system is not writable, this will throw an exception. We probably don't want…
				mbthomasAuthorUnsubmitted Not Done Aside from `debugtreedirstate cleanup`, we only ever cleanup when we've written to the dirstate already, which means it really ought to be possible to write here. That being said, I don't mind adding some belt-and-braces handling. Should I just ignore all exceptions that come out of cleanup, or are there specific ones? mbthomas: Aside from `debugtreedirstate cleanup`, we only ever cleanup when we've written to the dirstate…
				durhamUnsubmitted Not Done From the comment in wrapclose, I assumed cleanup was run on 1% of commands that read the dirstate as well? Maybe that big if statement in the wrapclose finally needs to be cleaned up to make it clearer when it runs? As for exceptions, usually IOError and OSError, but since this is the Lock class it might throw something special as well. durham: From the comment in wrapclose, I assumed cleanup was run on 1% of commands that read the…
				mbthomasAuthorUnsubmitted Not Done I think it throws Abort. I'll clean up the if statement and the comments to make it clear, but I think it should be ok to fail here if we make it this far and the repo is read-only. That shouldn't have happened, and I'd like to know that it did. mbthomas: I think it throws Abort. I'll clean up the if statement and the comments to make it clear, but…
				treesinuse = {}
				for f in dirstatefiles:
				try:
				treeid = gettreeid(repo.vfs, f)
				if treeid is not None:
				treesinuse.setdefault(treeid, set()).add(f)
				except Exception:
				pass
				for f in repo.vfs.listdir():
				if f.startswith(treefileprefix):
				treeid = f[len(treefileprefix):]
				if treeid not in treesinuse:
				ui.debug("dirstate tree %s unused, deleting\n" % treeid)
				repo.vfs.unlink(f)
				else:
				ui.debug("dirstate tree %s in use by %s\n"
				% (treeid, ', '.join(treesinuse[treeid])))

	def wrapdirstate(orig, self):			def wrapdirstate(orig, self):
	ds = orig(self)			ds = orig(self)
	if istreedirstate(self):			if istreedirstate(self):
	ds._mapcls = treedirstatemap			ds._mapcls = treedirstatemap
	return ds			return ds

	class casecollisionauditor(object):			class casecollisionauditor(object):
	def __init__(self, ui, abort, dirstate):			def __init__(self, ui, abort, dirstate):
	self._newfilesfolded.add(fl)			self._newfilesfolded.add(fl)

	def wrapcca(orig, ui, abort, dirstate):			def wrapcca(orig, ui, abort, dirstate):
	if util.safehasattr(dirstate._map, 'getcasefoldedtracked'):			if util.safehasattr(dirstate._map, 'getcasefoldedtracked'):
	return casecollisionauditor(ui, abort, dirstate)			return casecollisionauditor(ui, abort, dirstate)
	else:			else:
	return orig(ui, abort, dirstate)			return orig(ui, abort, dirstate)

				def wrapclose(orig, self):
				"""
				Wraps repo.close to perform cleanup of old dirstate tree files. This
				happens whenever the treefile is repacked, and also on 1% of other
				invocations that involve treedirstate.
				"""
				# For chg, do not clean up on the "serve" command
				if 'CHGINTERNALMARK' in os.environ:
				return orig(self)

				try:
				return orig(self)
				finally:
				if ("_map" in self.dirstate.__dict__ and
				isinstance(self.dirstate._map, treedirstatemap) and
				(getattr(self.dirstate._map, "_repacked", False) or
				(getattr(self.dirstate._map, "_extended", False) and
				random.random() < 0.01))):
				cleanup(self.ui, self)

				quarkUnsubmitted Not Done The cleanup logic does not look that expensive. Maybe it could be done as a post close hook of a transaction. At that time the wlock is still taken so you don't need to take another wlock (which is expensive for read-only commands). quark: The cleanup logic does not look that expensive. Maybe it could be done as a post close hook of…
				mbthomasAuthorUnsubmitted Not Done It only runs if the dirstate has been modified (based on `_repacked` or `_extended` being set), so read-only commands won't trigger a repack. I based this on what infinitepush backupcommand does at @stash's recommendation. Infinitepush used to use a transaction close hook, but it caused problems for commands that contain many transactions (e.g. `histedit`). I think it's a good idea to keep to one technique, too. What do you think? mbthomas: It only runs if the dirstate has been modified (based on `_repacked` or `_extended` being set)…
				quarkUnsubmitted Not Done Good point about histedit. The use of a separate wlock could potentially block the command unnecessarily. A transaction hook would avoid the lock issue and save a few ms on commands with a single transaction. Infinitepush backup needs to be fired at the end of the last write operation, but this cleanup does not have to. To avoid running cleanups multiple times, I think it could be done by having a per-process state. quark: Good point about histedit. The use of a separate wlock could potentially block the command…
				durhamUnsubmitted Not Done Could we wrap repo.close() instead? I also dislike wrapping runcommand and it'd be nice if we could start treating repo.close() as an actual repo destructor. durham: Could we wrap repo.close() instead? I also dislike wrapping runcommand and it'd be nice if we…
				mbthomasAuthorUnsubmitted Not Done I'll change to wrapping `repo.close()`. We still need to get the wlock separately, but cleanup happens rarely, so this should be ok. mbthomas: I'll change to wrapping `repo.close()`. We still need to get the wlock separately, but cleanup…
	def wrapnewreporequirements(orig, repo):			def wrapnewreporequirements(orig, repo):
	reqs = orig(repo)			reqs = orig(repo)
	reqs.add('treedirstate')			reqs.add('treedirstate')
	return reqs			return reqs

	def featuresetup(ui, supported):			def featuresetup(ui, supported):
	supported \|= {'treedirstate'}			supported \|= {'treedirstate'}

	def extsetup(ui):			def extsetup(ui):
	# Check this version of Mercurial has the extension points we need			# Check this version of Mercurial has the extension points we need
	if not util.safehasattr(dirstate.dirstatemap, "hasdir"):			if not util.safehasattr(dirstate.dirstatemap, "hasdir"):
	ui.warn(_("this version of Mercurial doesn't support treedirstate\n"))			ui.warn(_("this version of Mercurial doesn't support treedirstate\n"))
	return			return

	if useinnewrepos and util.safehasattr(localrepo, 'newreporequirements'):			if useinnewrepos and util.safehasattr(localrepo, 'newreporequirements'):
	extensions.wrapfunction(localrepo, 'newreporequirements',			extensions.wrapfunction(localrepo, 'newreporequirements',
	wrapnewreporequirements)			wrapnewreporequirements)

	localrepo.localrepository.featuresetupfuncs.add(featuresetup)			localrepo.localrepository.featuresetupfuncs.add(featuresetup)
	extensions.wrapfunction(localrepo.localrepository.dirstate, 'func',			extensions.wrapfunction(localrepo.localrepository.dirstate, 'func',
	wrapdirstate)			wrapdirstate)
	extensions.wrapfunction(scmutil, 'casecollisionauditor', wrapcca)			extensions.wrapfunction(scmutil, 'casecollisionauditor', wrapcca)
				extensions.wrapfunction(localrepo.localrepository, 'close', wrapclose)

	def reposetup(ui, repo):			def reposetup(ui, repo):
	ui.setconfig('treedirstate', 'enabled', istreedirstate(repo))			ui.setconfig('treedirstate', 'enabled', istreedirstate(repo))

	# debug commands			# debug commands
	cmdtable = {}			cmdtable = {}
	command = registrar.command(cmdtable)			command = registrar.command(cmdtable)

	@command('debugtreedirstate', [], 'hg debugtreedirstate [on\|off\|status]')			@command('debugtreedirstate', [],
				'hg debugtreedirstate [on\|off\|status\|repack\|cleanup]')
	def debugtreedirstate(ui, repo, cmd, **opts):			def debugtreedirstate(ui, repo, cmd, **opts):
	"""migrate to treedirstate"""			"""manage treedirstate"""
	if cmd == "on":			if cmd == "on":
	upgrade(ui, repo)			upgrade(ui, repo)
	elif cmd == "off":			elif cmd == "off":
	downgrade(ui, repo)			downgrade(ui, repo)
				cleanup(ui, repo)
				elif cmd == "repack":
				repack(ui, repo)
				cleanup(ui, repo)
				elif cmd == "cleanup":
				cleanup(ui, repo)
	elif cmd == "status":			elif cmd == "status":
	if istreedirstate(repo):			if istreedirstate(repo):
	ui.status(_("treedirstate enabled " +			ui.status(_("treedirstate enabled " +
	"(using dirstate.tree.%s, %s files tracked)")			"(using dirstate.tree.%s, %s files tracked)")
	% (repo.dirstate._map._treeid, len(repo.dirstate._map)))			% (repo.dirstate._map._treeid, len(repo.dirstate._map)))
	else:			else:
	ui.status(_("treedirstate not enabled"))			ui.status(_("treedirstate not enabled"))
	else:			else:
	raise error.Abort("unrecognised command: %s" % cmd)			raise error.Abort("unrecognised command: %s" % cmd)

			Path	Packages
M			rust/treedirstate/src/dirstate.rs (12 lines)
M			rust/treedirstate/src/filestore.rs (4 lines)
M			rust/treedirstate/src/python.rs (6 lines)
M			treedirstate/__init__.py (123 lines)

This is an archive of the discontinued Mercurial Phabricator instance.

treedirstate: auto-repack treedirstate once it reaches 3x its original size
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents
Changeset List

Diff 3775

rust/treedirstate/src/dirstate.rs

rust/treedirstate/src/filestore.rs

rust/treedirstate/src/python.rs

treedirstate/init.py

This is an archive of the discontinued Mercurial Phabricator instance.

treedirstate: auto-repack treedirstate once it reaches 3x its original sizeClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 3775

rust/treedirstate/src/dirstate.rs

rust/treedirstate/src/filestore.rs

rust/treedirstate/src/python.rs

treedirstate/__init__.py

treedirstate: auto-repack treedirstate once it reaches 3x its original size
ClosedPublic

Revision Contents
Changeset List

treedirstate/init.py