/brz/remove-bazaar : contents of bzrlib/memorytree.py at revision 2831.8.1

: (revision 2831.8.1)

To get this branch, use:

bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

# Copyright (C) 2006 Canonical Ltd
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""MemoryTree object.

See MemoryTree for more details.
"""


from copy import deepcopy

from bzrlib import (
    errors,
    mutabletree,
    revision as _mod_revision,
    )
from bzrlib.decorators import needs_read_lock, needs_write_lock
from bzrlib.osutils import sha_file
from bzrlib.mutabletree import needs_tree_write_lock
from bzrlib.transport.memory import MemoryTransport


class MemoryTree(mutabletree.MutableTree):
    """A MemoryTree is a specialisation of MutableTree.
    
    It maintains nearly no state outside of read_lock and write_lock
    transactions. (it keeps a reference to the branch, and its last-revision
    only).
    """

    def __init__(self, branch, revision_id):
        """Construct a MemoryTree for branch using revision_id."""
        self.branch = branch
        self.bzrdir = branch.bzrdir
        self._branch_revision_id = revision_id
        self._locks = 0
        self._lock_mode = None

    @needs_tree_write_lock
    def _add(self, files, ids, kinds):
        """See MutableTree._add."""
        for f, file_id, kind in zip(files, ids, kinds):
            if kind is None:
                kind = 'file'
            if file_id is None:
                self._inventory.add_path(f, kind=kind)
            else:
                self._inventory.add_path(f, kind=kind, file_id=file_id)

    def basis_tree(self):
        """See Tree.basis_tree()."""
        return self._basis_tree

    @staticmethod
    def create_on_branch(branch):
        """Create a MemoryTree for branch, using the last-revision of branch."""
        revision_id = _mod_revision.ensure_null(branch.last_revision())
        if _mod_revision.is_null(revision_id):
            revision_id = None
        return MemoryTree(branch, revision_id)

    def _gather_kinds(self, files, kinds):
        """See MutableTree._gather_kinds.
        
        This implementation does not care about the file kind of
        missing files, so is a no-op.
        """

    def get_file(self, file_id, path=None):
        """See Tree.get_file."""
        if path is None:
            path = self.id2path(file_id)
        return self._file_transport.get(path)

    def get_file_sha1(self, file_id, path=None, stat_value=None):
        """See Tree.get_file_sha1()."""
        if path is None:
            path = self.id2path(file_id)
        stream = self._file_transport.get(path)
        return sha_file(stream)

    def _comparison_data(self, entry, path):
        """See Tree._comparison_data."""
        if entry is None:
            return None, False, None
        return entry.kind, entry.executable, None

    def _file_size(self, entry, stat_value):
        """See Tree._file_size."""
        if entry is None:
            return 0
        return entry.text_size

    @needs_read_lock
    def get_parent_ids(self):
        """See Tree.get_parent_ids.

        This implementation returns the current cached value from
            self._parent_ids.
        """
        return list(self._parent_ids)

    def has_filename(self, filename):
        """See Tree.has_filename()."""
        return self._file_transport.has(filename)

    def is_executable(self, file_id, path=None):
        return self._inventory[file_id].executable

    def kind(self, file_id):
        return self._inventory[file_id].kind

    def mkdir(self, path, file_id=None):
        """See MutableTree.mkdir()."""
        self.add(path, file_id, 'directory')
        if file_id is None:
            file_id = self.path2id(path)
        self._file_transport.mkdir(path)
        return file_id

    @needs_read_lock
    def last_revision(self):
        """See MutableTree.last_revision."""
        return self._branch_revision_id

    def lock_read(self):
        """Lock the memory tree for reading.

        This triggers population of data from the branch for its revision.
        """
        self._locks += 1
        try:
            if self._locks == 1:
                self.branch.lock_read()
                self._lock_mode = "r"
                self._populate_from_branch()
        except:
            self._locks -= 1
            raise

    def lock_tree_write(self):
        """See MutableTree.lock_tree_write()."""
        self._locks += 1
        try:
            if self._locks == 1:
                self.branch.lock_read()
                self._lock_mode = "w"
                self._populate_from_branch()
            elif self._lock_mode == "r":
                raise errors.ReadOnlyError(self)
        except:
            self._locks -= 1
            raise

    def lock_write(self):
        """See MutableTree.lock_write()."""
        self._locks += 1
        try:
            if self._locks == 1:
                self.branch.lock_write()
                self._lock_mode = "w"
                self._populate_from_branch()
            elif self._lock_mode == "r":
                raise errors.ReadOnlyError(self)
        except:
            self._locks -= 1
            raise

    def _populate_from_branch(self):
        """Populate the in-tree state from the branch."""
        self._basis_tree = self.branch.repository.revision_tree(
            self._branch_revision_id)
        if self._branch_revision_id is None:
            self._parent_ids = []
        else:
            self._parent_ids = [self._branch_revision_id]
        self._inventory = deepcopy(self._basis_tree._inventory)
        self._file_transport = MemoryTransport()
        # TODO copy the revision trees content, or do it lazy, or something.
        inventory_entries = self._inventory.iter_entries()
        for path, entry in inventory_entries:
            if path == '':
                continue
            if entry.kind == 'directory':
                self._file_transport.mkdir(path)
            elif entry.kind == 'file':
                self._file_transport.put_file(path,
                    self._basis_tree.get_file(entry.file_id))
            else:
                raise NotImplementedError(self._populate_from_branch)

    def put_file_bytes_non_atomic(self, file_id, bytes):
        """See MutableTree.put_file_bytes_non_atomic."""
        self._file_transport.put_bytes(self.id2path(file_id), bytes)

    def unlock(self):
        """Release a lock.

        This frees all cached state when the last lock context for the tree is
        left.
        """
        if self._locks == 1:
            self._basis_tree = None
            self._parent_ids = []
            self._inventory = None
            try:
                self.branch.unlock()
            finally:
                self._locks = 0
                self._lock_mode = None
        else:
            self._locks -= 1

    @needs_tree_write_lock
    def unversion(self, file_ids):
        """Remove the file ids in file_ids from the current versioned set.

        When a file_id is unversioned, all of its children are automatically
        unversioned.

        :param file_ids: The file ids to stop versioning.
        :raises: NoSuchId if any fileid is not currently versioned.
        """
        # XXX: This should be in mutabletree, but the inventory-save action
        # is not relevant to memory tree. Until that is done in unlock by
        # working tree, we cannot share the implementation.
        for file_id in file_ids:
            if self._inventory.has_id(file_id):
                self._inventory.remove_recursive_id(file_id)
            else:
                raise errors.NoSuchId(self, file_id)

    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
        """See MutableTree.set_parent_trees()."""
        for revision_id in revision_ids:
            _mod_revision.check_not_reserved_id(revision_id)
        if len(revision_ids) == 0:
            self._parent_ids = []
            self._basis_tree = self.branch.repository.revision_tree(None)
        else:
            self._parent_ids = revision_ids
            self._basis_tree = self.branch.repository.revision_tree(
                                    revision_ids[0])
            self._branch_revision_id = revision_ids[0]

    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
        """See MutableTree.set_parent_trees()."""
        if len(parents_list) == 0:
            self._parent_ids = []
            self._basis_tree = self.branch.repository.revision_tree(None)
        else:
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
                # a ghost in the left most parent
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
                import pdb; pdb.set_trace()
                self._basis_tree = self.branch.repository.revision_tree(None)
            else:
                self._basis_tree = parents_list[0][1]
            self._branch_revision_id = parents_list[0][0]

1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	1	# Copyright (C) 2006 Canonical Ltd
	2	#
	3	# This program is free software; you can redistribute it and/or modify
	4	# it under the terms of the GNU General Public License as published by
	5	# the Free Software Foundation; either version 2 of the License, or
	6	# (at your option) any later version.
	7	#
	8	# This program is distributed in the hope that it will be useful,
	9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	# GNU General Public License for more details.
	12	#
	13	# You should have received a copy of the GNU General Public License
	14	# along with this program; if not, write to the Free Software
	15	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	16
	17	"""MemoryTree object.
	18
	19	See MemoryTree for more details.
	20	"""
	21
	22
	23	from copy import deepcopy
	24
2598.5.1 by Aaron Bentley Start eliminating the use of None to indicate null revision	25	from bzrlib import (
	26	errors,
	27	mutabletree,
	28	revision as _mod_revision,
	29	)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	30	from bzrlib.decorators import needs_read_lock, needs_write_lock
	31	from bzrlib.osutils import sha_file
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	32	from bzrlib.mutabletree import needs_tree_write_lock
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	33	from bzrlib.transport.memory import MemoryTransport
	34
	35
	36	class MemoryTree(mutabletree.MutableTree):
	37	"""A MemoryTree is a specialisation of MutableTree.
	38
	39	It maintains nearly no state outside of read_lock and write_lock
	40	transactions. (it keeps a reference to the branch, and its last-revision
	41	only).
	42	"""
	43
	44	def __init__(self, branch, revision_id):
	45	"""Construct a MemoryTree for branch using revision_id."""
	46	self.branch = branch
	47	self.bzrdir = branch.bzrdir
	48	self._branch_revision_id = revision_id
	49	self._locks = 0
	50	self._lock_mode = None
	51
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	52	@needs_tree_write_lock
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	53	def _add(self, files, ids, kinds):
	54	"""See MutableTree._add."""
	55	for f, file_id, kind in zip(files, ids, kinds):
	56	if kind is None:
	57	kind = 'file'
	58	if file_id is None:
	59	self._inventory.add_path(f, kind=kind)
	60	else:
	61	self._inventory.add_path(f, kind=kind, file_id=file_id)
	62
	63	def basis_tree(self):
	64	"""See Tree.basis_tree()."""
	65	return self._basis_tree
	66
	67	@staticmethod
	68	def create_on_branch(branch):
	69	"""Create a MemoryTree for branch, using the last-revision of branch."""
2598.5.4 by Aaron Bentley Restore original Branch.last_revision behavior, fix bits that care	70	revision_id = _mod_revision.ensure_null(branch.last_revision())
2598.5.1 by Aaron Bentley Start eliminating the use of None to indicate null revision	71	if _mod_revision.is_null(revision_id):
	72	revision_id = None
	73	return MemoryTree(branch, revision_id)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	74
	75	def _gather_kinds(self, files, kinds):
	76	"""See MutableTree._gather_kinds.
	77
	78	This implementation does not care about the file kind of
	79	missing files, so is a no-op.
	80	"""
	81
2743.3.3 by Ian Clatworthy Skip path lookup for tree.get_file() when we already know the path	82	def get_file(self, file_id, path=None):
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	83	"""See Tree.get_file."""
2743.3.3 by Ian Clatworthy Skip path lookup for tree.get_file() when we already know the path	84	if path is None:
	85	path = self.id2path(file_id)
	86	return self._file_transport.get(path)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	87
2564.2.1 by Ian Clatworthy refactor commit to support alternative population meothds	88	def get_file_sha1(self, file_id, path=None, stat_value=None):
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	89	"""See Tree.get_file_sha1()."""
	90	if path is None:
	91	path = self.id2path(file_id)
	92	stream = self._file_transport.get(path)
	93	return sha_file(stream)
	94
2564.2.1 by Ian Clatworthy refactor commit to support alternative population meothds	95	def _comparison_data(self, entry, path):
	96	"""See Tree._comparison_data."""
	97	if entry is None:
	98	return None, False, None
	99	return entry.kind, entry.executable, None
	100
	101	def _file_size(self, entry, stat_value):
	102	"""See Tree._file_size."""
	103	if entry is None:
	104	return 0
	105	return entry.text_size
	106
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	107	@needs_read_lock
	108	def get_parent_ids(self):
	109	"""See Tree.get_parent_ids.
	110
	111	This implementation returns the current cached value from
	112	self._parent_ids.
	113	"""
	114	return list(self._parent_ids)
	115
	116	def has_filename(self, filename):
	117	"""See Tree.has_filename()."""
	118	return self._file_transport.has(filename)
	119
	120	def is_executable(self, file_id, path=None):
	121	return self._inventory[file_id].executable
	122
1959.4.2 by Aaron Bentley Merge bzr.dev	123	def kind(self, file_id):
	124	return self._inventory[file_id].kind
	125
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	126	def mkdir(self, path, file_id=None):
	127	"""See MutableTree.mkdir()."""
	128	self.add(path, file_id, 'directory')
	129	if file_id is None:
	130	file_id = self.path2id(path)
	131	self._file_transport.mkdir(path)
	132	return file_id
	133
1986.1.6 by Robert Collins Add MemoryTree.last_revision.	134	@needs_read_lock
	135	def last_revision(self):
	136	"""See MutableTree.last_revision."""
	137	return self._branch_revision_id
	138
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	139	def lock_read(self):
	140	"""Lock the memory tree for reading.
	141
	142	This triggers population of data from the branch for its revision.
	143	"""
	144	self._locks += 1
	145	try:
	146	if self._locks == 1:
	147	self.branch.lock_read()
	148	self._lock_mode = "r"
	149	self._populate_from_branch()
	150	except:
	151	self._locks -= 1
	152	raise
	153
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	154	def lock_tree_write(self):
	155	"""See MutableTree.lock_tree_write()."""
	156	self._locks += 1
	157	try:
	158	if self._locks == 1:
	159	self.branch.lock_read()
	160	self._lock_mode = "w"
	161	self._populate_from_branch()
	162	elif self._lock_mode == "r":
	163	raise errors.ReadOnlyError(self)
	164	except:
	165	self._locks -= 1
	166	raise
	167
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	168	def lock_write(self):
	169	"""See MutableTree.lock_write()."""
	170	self._locks += 1
	171	try:
	172	if self._locks == 1:
	173	self.branch.lock_write()
	174	self._lock_mode = "w"
	175	self._populate_from_branch()
	176	elif self._lock_mode == "r":
	177	raise errors.ReadOnlyError(self)
	178	except:
	179	self._locks -= 1
	180	raise
	181
	182	def _populate_from_branch(self):
	183	"""Populate the in-tree state from the branch."""
	184	self._basis_tree = self.branch.repository.revision_tree(
	185	self._branch_revision_id)
	186	if self._branch_revision_id is None:
	187	self._parent_ids = []
	188	else:
	189	self._parent_ids = [self._branch_revision_id]
	190	self._inventory = deepcopy(self._basis_tree._inventory)
	191	self._file_transport = MemoryTransport()
	192	# TODO copy the revision trees content, or do it lazy, or something.
	193	inventory_entries = self._inventory.iter_entries()
	194	for path, entry in inventory_entries:
1731.1.50 by Aaron Bentley Merge bzr.dev	195	if path == '':
1731.1.50 by Aaron Bentley Merge bzr.dev	196	continue
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	197	if entry.kind == 'directory':
	198	self._file_transport.mkdir(path)
	199	elif entry.kind == 'file':
1986.1.4 by Robert Collins Fixup deprecations from bzr.dev.	200	self._file_transport.put_file(path,
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	201	self._basis_tree.get_file(entry.file_id))
	202	else:
	203	raise NotImplementedError(self._populate_from_branch)
	204
	205	def put_file_bytes_non_atomic(self, file_id, bytes):
	206	"""See MutableTree.put_file_bytes_non_atomic."""
1986.1.4 by Robert Collins Fixup deprecations from bzr.dev.	207	self._file_transport.put_bytes(self.id2path(file_id), bytes)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	208
	209	def unlock(self):
	210	"""Release a lock.
	211
	212	This frees all cached state when the last lock context for the tree is
	213	left.
	214	"""
	215	if self._locks == 1:
	216	self._basis_tree = None
	217	self._parent_ids = []
	218	self._inventory = None
	219	try:
	220	self.branch.unlock()
	221	finally:
	222	self._locks = 0
	223	self._lock_mode = None
	224	else:
	225	self._locks -= 1
	226
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	227	@needs_tree_write_lock
1986.1.3 by Robert Collins Merge bzr.dev.	228	def unversion(self, file_ids):
	229	"""Remove the file ids in file_ids from the current versioned set.
	230
	231	When a file_id is unversioned, all of its children are automatically
	232	unversioned.
	233
	234	:param file_ids: The file ids to stop versioning.
	235	:raises: NoSuchId if any fileid is not currently versioned.
	236	"""
	237	# XXX: This should be in mutabletree, but the inventory-save action
	238	# is not relevant to memory tree. Until that is done in unlock by
	239	# working tree, we cannot share the implementation.
	240	for file_id in file_ids:
	241	if self._inventory.has_id(file_id):
	242	self._inventory.remove_recursive_id(file_id)
	243	else:
	244	raise errors.NoSuchId(self, file_id)
	245
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	246	def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
	247	"""See MutableTree.set_parent_trees()."""
2598.5.2 by Aaron Bentley Got all tests passing with Branch returning 'null:' for null revision	248	for revision_id in revision_ids:
	249	_mod_revision.check_not_reserved_id(revision_id)
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	250	if len(revision_ids) == 0:
	251	self._parent_ids = []
	252	self._basis_tree = self.branch.repository.revision_tree(None)
	253	else:
	254	self._parent_ids = revision_ids
	255	self._basis_tree = self.branch.repository.revision_tree(
	256	revision_ids[0])
	257	self._branch_revision_id = revision_ids[0]
	258
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	259	def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
	260	"""See MutableTree.set_parent_trees()."""
	261	if len(parents_list) == 0:
	262	self._parent_ids = []
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	263	self._basis_tree = self.branch.repository.revision_tree(None)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	264	else:
	265	if parents_list[0][1] is None and not allow_leftmost_as_ghost:
	266	# a ghost in the left most parent
	267	raise errors.GhostRevisionUnusableHere(parents_list[0][0])
	268	self._parent_ids = [parent_id for parent_id, tree in parents_list]
2598.5.2 by Aaron Bentley Got all tests passing with Branch returning 'null:' for null revision	269	if parents_list[0][1] is None or parents_list[0][1] == 'null:':
	270	import pdb; pdb.set_trace()
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	271	self._basis_tree = self.branch.repository.revision_tree(None)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	272	else:
	273	self._basis_tree = parents_list[0][1]
1986.1.6 by Robert Collins Add MemoryTree.last_revision.	274	self._branch_revision_id = parents_list[0][0]