~bzr-pqm/bzr/bzr.dev : contents of bzrlib/memorytree.py at revision 3696.1.1

~bzr-pqm/bzr/bzr.dev : (revision 3696.1.1)

# 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())
        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 get_root_id(self):
        return self.path2id('')

    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 path_content_summary(self, path):
        """See Tree.path_content_summary."""
        id = self.path2id(path)
        if id is None:
            return 'missing', None, None, None
        kind = self.kind(id)
        if kind == 'file':
            bytes = self._file_transport.get_bytes(path)
            size = len(bytes)
            executable = self._inventory[id].executable
            sha1 = None # no stat cache
            return (kind, size, executable, sha1)
        elif kind == 'directory':
            # memory tree does not support nested trees yet.
            return kind, None, None, None
        elif kind == 'symlink':
            raise NotImplementedError('symlink support')
        else:
            raise NotImplementedError('unknown kind')

    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 == _mod_revision.NULL_REVISION:
            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(
                                    _mod_revision.NULL_REVISION)
        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(
                                   _mod_revision.NULL_REVISION)
        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:':
                self._basis_tree = self.branch.repository.revision_tree(
                                       _mod_revision.NULL_REVISION)
            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	return MemoryTree(branch, revision_id)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	72
	73	def _gather_kinds(self, files, kinds):
	74	"""See MutableTree._gather_kinds.
	75
	76	This implementation does not care about the file kind of
	77	missing files, so is a no-op.
	78	"""
	79
2743.3.3 by Ian Clatworthy Skip path lookup for tree.get_file() when we already know the path	80	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	81	"""See Tree.get_file."""
2743.3.3 by Ian Clatworthy Skip path lookup for tree.get_file() when we already know the path	82	if path is None:
	83	path = self.id2path(file_id)
	84	return self._file_transport.get(path)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	85
2564.2.1 by Ian Clatworthy refactor commit to support alternative population meothds	86	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	87	"""See Tree.get_file_sha1()."""
	88	if path is None:
	89	path = self.id2path(file_id)
	90	stream = self._file_transport.get(path)
	91	return sha_file(stream)
	92
2946.3.5 by John Arbash Meinel MemoryTree is not tested under the tree_implementations tests.	93	def get_root_id(self):
	94	return self.path2id('')
	95
2564.2.1 by Ian Clatworthy refactor commit to support alternative population meothds	96	def _comparison_data(self, entry, path):
	97	"""See Tree._comparison_data."""
	98	if entry is None:
	99	return None, False, None
	100	return entry.kind, entry.executable, None
	101
2776.4.2 by Robert Collins nuke _read_tree_state and snapshot from inventory, moving responsibility into the commit builder.	102	def path_content_summary(self, path):
	103	"""See Tree.path_content_summary."""
	104	id = self.path2id(path)
	105	if id is None:
	106	return 'missing', None, None, None
	107	kind = self.kind(id)
	108	if kind == 'file':
	109	bytes = self._file_transport.get_bytes(path)
	110	size = len(bytes)
	111	executable = self._inventory[id].executable
	112	sha1 = None # no stat cache
	113	return (kind, size, executable, sha1)
	114	elif kind == 'directory':
	115	# memory tree does not support nested trees yet.
	116	return kind, None, None, None
	117	elif kind == 'symlink':
	118	raise NotImplementedError('symlink support')
	119	else:
	120	raise NotImplementedError('unknown kind')
	121
2564.2.1 by Ian Clatworthy refactor commit to support alternative population meothds	122	def _file_size(self, entry, stat_value):
	123	"""See Tree._file_size."""
	124	if entry is None:
	125	return 0
	126	return entry.text_size
	127
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	128	@needs_read_lock
	129	def get_parent_ids(self):
	130	"""See Tree.get_parent_ids.
	131
	132	This implementation returns the current cached value from
	133	self._parent_ids.
	134	"""
	135	return list(self._parent_ids)
	136
	137	def has_filename(self, filename):
	138	"""See Tree.has_filename()."""
	139	return self._file_transport.has(filename)
	140
	141	def is_executable(self, file_id, path=None):
	142	return self._inventory[file_id].executable
	143
1959.4.2 by Aaron Bentley Merge bzr.dev	144	def kind(self, file_id):
	145	return self._inventory[file_id].kind
	146
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	147	def mkdir(self, path, file_id=None):
	148	"""See MutableTree.mkdir()."""
	149	self.add(path, file_id, 'directory')
	150	if file_id is None:
	151	file_id = self.path2id(path)
	152	self._file_transport.mkdir(path)
	153	return file_id
	154
1986.1.6 by Robert Collins Add MemoryTree.last_revision.	155	@needs_read_lock
	156	def last_revision(self):
	157	"""See MutableTree.last_revision."""
	158	return self._branch_revision_id
	159
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	160	def lock_read(self):
	161	"""Lock the memory tree for reading.
	162
	163	This triggers population of data from the branch for its revision.
	164	"""
	165	self._locks += 1
	166	try:
	167	if self._locks == 1:
	168	self.branch.lock_read()
	169	self._lock_mode = "r"
	170	self._populate_from_branch()
	171	except:
	172	self._locks -= 1
	173	raise
	174
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	175	def lock_tree_write(self):
	176	"""See MutableTree.lock_tree_write()."""
	177	self._locks += 1
	178	try:
	179	if self._locks == 1:
	180	self.branch.lock_read()
	181	self._lock_mode = "w"
	182	self._populate_from_branch()
	183	elif self._lock_mode == "r":
	184	raise errors.ReadOnlyError(self)
	185	except:
	186	self._locks -= 1
	187	raise
	188
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	189	def lock_write(self):
	190	"""See MutableTree.lock_write()."""
	191	self._locks += 1
	192	try:
	193	if self._locks == 1:
	194	self.branch.lock_write()
	195	self._lock_mode = "w"
	196	self._populate_from_branch()
	197	elif self._lock_mode == "r":
	198	raise errors.ReadOnlyError(self)
	199	except:
	200	self._locks -= 1
	201	raise
	202
	203	def _populate_from_branch(self):
	204	"""Populate the in-tree state from the branch."""
	205	self._basis_tree = self.branch.repository.revision_tree(
	206	self._branch_revision_id)
3668.5.4 by Jelmer Vernooij Eliminate more uses of Repository.revision_tree(None).	207	if self._branch_revision_id == _mod_revision.NULL_REVISION:
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	208	self._parent_ids = []
	209	else:
	210	self._parent_ids = [self._branch_revision_id]
	211	self._inventory = deepcopy(self._basis_tree._inventory)
	212	self._file_transport = MemoryTransport()
	213	# TODO copy the revision trees content, or do it lazy, or something.
	214	inventory_entries = self._inventory.iter_entries()
	215	for path, entry in inventory_entries:
1731.1.50 by Aaron Bentley Merge bzr.dev	216	if path == '':
1731.1.50 by Aaron Bentley Merge bzr.dev	217	continue
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	218	if entry.kind == 'directory':
	219	self._file_transport.mkdir(path)
	220	elif entry.kind == 'file':
1986.1.4 by Robert Collins Fixup deprecations from bzr.dev.	221	self._file_transport.put_file(path,
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	222	self._basis_tree.get_file(entry.file_id))
	223	else:
	224	raise NotImplementedError(self._populate_from_branch)
	225
	226	def put_file_bytes_non_atomic(self, file_id, bytes):
	227	"""See MutableTree.put_file_bytes_non_atomic."""
1986.1.4 by Robert Collins Fixup deprecations from bzr.dev.	228	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	229
	230	def unlock(self):
	231	"""Release a lock.
	232
	233	This frees all cached state when the last lock context for the tree is
	234	left.
	235	"""
	236	if self._locks == 1:
	237	self._basis_tree = None
	238	self._parent_ids = []
	239	self._inventory = None
	240	try:
	241	self.branch.unlock()
	242	finally:
	243	self._locks = 0
	244	self._lock_mode = None
	245	else:
	246	self._locks -= 1
	247
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	248	@needs_tree_write_lock
1986.1.3 by Robert Collins Merge bzr.dev.	249	def unversion(self, file_ids):
	250	"""Remove the file ids in file_ids from the current versioned set.
	251
	252	When a file_id is unversioned, all of its children are automatically
	253	unversioned.
	254
	255	:param file_ids: The file ids to stop versioning.
	256	:raises: NoSuchId if any fileid is not currently versioned.
	257	"""
	258	# XXX: This should be in mutabletree, but the inventory-save action
	259	# is not relevant to memory tree. Until that is done in unlock by
	260	# working tree, we cannot share the implementation.
	261	for file_id in file_ids:
	262	if self._inventory.has_id(file_id):
	263	self._inventory.remove_recursive_id(file_id)
	264	else:
	265	raise errors.NoSuchId(self, file_id)
	266
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	267	def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
	268	"""See MutableTree.set_parent_trees()."""
2598.5.2 by Aaron Bentley Got all tests passing with Branch returning 'null:' for null revision	269	for revision_id in revision_ids:
	270	_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.	271	if len(revision_ids) == 0:
	272	self._parent_ids = []
3668.5.1 by Jelmer Vernooij Use NULL_REVISION rather than None for Repository.revision_tree().	273	self._basis_tree = self.branch.repository.revision_tree(
	274	_mod_revision.NULL_REVISION)
2418.5.1 by John Arbash Meinel Make a Branch helper which can create a very basic MemoryTree with history.	275	else:
	276	self._parent_ids = revision_ids
	277	self._basis_tree = self.branch.repository.revision_tree(
	278	revision_ids[0])
	279	self._branch_revision_id = revision_ids[0]
	280
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	281	def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
	282	"""See MutableTree.set_parent_trees()."""
	283	if len(parents_list) == 0:
	284	self._parent_ids = []
3668.5.1 by Jelmer Vernooij Use NULL_REVISION rather than None for Repository.revision_tree().	285	self._basis_tree = self.branch.repository.revision_tree(
	286	_mod_revision.NULL_REVISION)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	287	else:
	288	if parents_list[0][1] is None and not allow_leftmost_as_ghost:
	289	# a ghost in the left most parent
	290	raise errors.GhostRevisionUnusableHere(parents_list[0][0])
	291	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	292	if parents_list[0][1] is None or parents_list[0][1] == 'null:':
3668.5.1 by Jelmer Vernooij Use NULL_REVISION rather than None for Repository.revision_tree().	293	self._basis_tree = self.branch.repository.revision_tree(
	294	_mod_revision.NULL_REVISION)
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	295	else:
	296	self._basis_tree = parents_list[0][1]
1986.1.6 by Robert Collins Add MemoryTree.last_revision.	297	self._branch_revision_id = parents_list[0][0]