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

~bzr-pqm/bzr/bzr.dev : (revision 2378.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
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."""
        return MemoryTree(branch, branch.last_revision())

    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):
        """See Tree.get_file."""
        return self._file_transport.get(self.id2path(file_id))

    def get_file_sha1(self, file_id, path=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)

    @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_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.revisiontree(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:
                self._basis_tree = self.branch.repository.revisiontree(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
	25	from bzrlib import errors, mutabletree
	26	from bzrlib.decorators import needs_read_lock, needs_write_lock
	27	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.	28	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	29	from bzrlib.transport.memory import MemoryTransport
	30
	31
	32	class MemoryTree(mutabletree.MutableTree):
	33	"""A MemoryTree is a specialisation of MutableTree.
	34
	35	It maintains nearly no state outside of read_lock and write_lock
	36	transactions. (it keeps a reference to the branch, and its last-revision
	37	only).
	38	"""
	39
	40	def __init__(self, branch, revision_id):
	41	"""Construct a MemoryTree for branch using revision_id."""
	42	self.branch = branch
	43	self.bzrdir = branch.bzrdir
	44	self._branch_revision_id = revision_id
	45	self._locks = 0
	46	self._lock_mode = None
	47
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	48	@needs_tree_write_lock
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	49	def _add(self, files, ids, kinds):
	50	"""See MutableTree._add."""
	51	for f, file_id, kind in zip(files, ids, kinds):
	52	if kind is None:
	53	kind = 'file'
	54	if file_id is None:
	55	self._inventory.add_path(f, kind=kind)
	56	else:
	57	self._inventory.add_path(f, kind=kind, file_id=file_id)
	58
	59	def basis_tree(self):
	60	"""See Tree.basis_tree()."""
	61	return self._basis_tree
	62
	63	@staticmethod
	64	def create_on_branch(branch):
	65	"""Create a MemoryTree for branch, using the last-revision of branch."""
	66	return MemoryTree(branch, branch.last_revision())
	67
	68	def _gather_kinds(self, files, kinds):
	69	"""See MutableTree._gather_kinds.
	70
	71	This implementation does not care about the file kind of
	72	missing files, so is a no-op.
	73	"""
	74
	75	def get_file(self, file_id):
	76	"""See Tree.get_file."""
	77	return self._file_transport.get(self.id2path(file_id))
	78
	79	def get_file_sha1(self, file_id, path=None):
	80	"""See Tree.get_file_sha1()."""
	81	if path is None:
	82	path = self.id2path(file_id)
	83	stream = self._file_transport.get(path)
	84	return sha_file(stream)
	85
	86	@needs_read_lock
	87	def get_parent_ids(self):
	88	"""See Tree.get_parent_ids.
	89
	90	This implementation returns the current cached value from
	91	self._parent_ids.
	92	"""
	93	return list(self._parent_ids)
	94
	95	def has_filename(self, filename):
	96	"""See Tree.has_filename()."""
	97	return self._file_transport.has(filename)
	98
	99	def is_executable(self, file_id, path=None):
	100	return self._inventory[file_id].executable
	101
1959.4.2 by Aaron Bentley Merge bzr.dev	102	def kind(self, file_id):
	103	return self._inventory[file_id].kind
	104
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	105	def mkdir(self, path, file_id=None):
	106	"""See MutableTree.mkdir()."""
	107	self.add(path, file_id, 'directory')
	108	if file_id is None:
	109	file_id = self.path2id(path)
	110	self._file_transport.mkdir(path)
	111	return file_id
	112
1986.1.6 by Robert Collins Add MemoryTree.last_revision.	113	@needs_read_lock
	114	def last_revision(self):
	115	"""See MutableTree.last_revision."""
	116	return self._branch_revision_id
	117
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	118	def lock_read(self):
	119	"""Lock the memory tree for reading.
	120
	121	This triggers population of data from the branch for its revision.
	122	"""
	123	self._locks += 1
	124	try:
	125	if self._locks == 1:
	126	self.branch.lock_read()
	127	self._lock_mode = "r"
	128	self._populate_from_branch()
	129	except:
	130	self._locks -= 1
	131	raise
	132
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	133	def lock_tree_write(self):
	134	"""See MutableTree.lock_tree_write()."""
	135	self._locks += 1
	136	try:
	137	if self._locks == 1:
	138	self.branch.lock_read()
	139	self._lock_mode = "w"
	140	self._populate_from_branch()
	141	elif self._lock_mode == "r":
	142	raise errors.ReadOnlyError(self)
	143	except:
	144	self._locks -= 1
	145	raise
	146
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	147	def lock_write(self):
	148	"""See MutableTree.lock_write()."""
	149	self._locks += 1
	150	try:
	151	if self._locks == 1:
	152	self.branch.lock_write()
	153	self._lock_mode = "w"
	154	self._populate_from_branch()
	155	elif self._lock_mode == "r":
	156	raise errors.ReadOnlyError(self)
	157	except:
	158	self._locks -= 1
	159	raise
	160
	161	def _populate_from_branch(self):
	162	"""Populate the in-tree state from the branch."""
	163	self._basis_tree = self.branch.repository.revision_tree(
	164	self._branch_revision_id)
	165	if self._branch_revision_id is None:
	166	self._parent_ids = []
	167	else:
	168	self._parent_ids = [self._branch_revision_id]
	169	self._inventory = deepcopy(self._basis_tree._inventory)
	170	self._file_transport = MemoryTransport()
	171	# TODO copy the revision trees content, or do it lazy, or something.
	172	inventory_entries = self._inventory.iter_entries()
	173	for path, entry in inventory_entries:
1731.1.50 by Aaron Bentley Merge bzr.dev	174	if path == '':
1731.1.50 by Aaron Bentley Merge bzr.dev	175	continue
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	176	if entry.kind == 'directory':
	177	self._file_transport.mkdir(path)
	178	elif entry.kind == 'file':
1986.1.4 by Robert Collins Fixup deprecations from bzr.dev.	179	self._file_transport.put_file(path,
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	180	self._basis_tree.get_file(entry.file_id))
	181	else:
	182	raise NotImplementedError(self._populate_from_branch)
	183
	184	def put_file_bytes_non_atomic(self, file_id, bytes):
	185	"""See MutableTree.put_file_bytes_non_atomic."""
1986.1.4 by Robert Collins Fixup deprecations from bzr.dev.	186	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	187
	188	def unlock(self):
	189	"""Release a lock.
	190
	191	This frees all cached state when the last lock context for the tree is
	192	left.
	193	"""
	194	if self._locks == 1:
	195	self._basis_tree = None
	196	self._parent_ids = []
	197	self._inventory = None
	198	try:
	199	self.branch.unlock()
	200	finally:
	201	self._locks = 0
	202	self._lock_mode = None
	203	else:
	204	self._locks -= 1
	205
1986.1.8 by Robert Collins Update to bzr.dev, which involves adding lock_tree_write to MutableTree and MemoryTree.	206	@needs_tree_write_lock
1986.1.3 by Robert Collins Merge bzr.dev.	207	def unversion(self, file_ids):
	208	"""Remove the file ids in file_ids from the current versioned set.
	209
	210	When a file_id is unversioned, all of its children are automatically
	211	unversioned.
	212
	213	:param file_ids: The file ids to stop versioning.
	214	:raises: NoSuchId if any fileid is not currently versioned.
	215	"""
	216	# XXX: This should be in mutabletree, but the inventory-save action
	217	# is not relevant to memory tree. Until that is done in unlock by
	218	# working tree, we cannot share the implementation.
	219	for file_id in file_ids:
	220	if self._inventory.has_id(file_id):
	221	self._inventory.remove_recursive_id(file_id)
	222	else:
	223	raise errors.NoSuchId(self, file_id)
	224
1986.1.2 by Robert Collins Various changes to allow non-workingtree specific tests to run entirely	225	def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
	226	"""See MutableTree.set_parent_trees()."""
	227	if len(parents_list) == 0:
	228	self._parent_ids = []
	229	self._basis_tree = self.branch.repository.revisiontree(None)
	230	else:
	231	if parents_list[0][1] is None and not allow_leftmost_as_ghost:
	232	# a ghost in the left most parent
	233	raise errors.GhostRevisionUnusableHere(parents_list[0][0])
	234	self._parent_ids = [parent_id for parent_id, tree in parents_list]
	235	if parents_list[0][1] is None:
	236	self._basis_tree = self.branch.repository.revisiontree(None)
	237	else:
	238	self._basis_tree = parents_list[0][1]
1986.1.6 by Robert Collins Add MemoryTree.last_revision.	239	self._branch_revision_id = parents_list[0][0]