← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/memorytree.py

- help for global options

- test for this

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/memorytree.py
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
28
 
from bzrlib.mutabletree import needs_tree_write_lock
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
 
 
48
 
    @needs_tree_write_lock
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
 
 
102
 
    def mkdir(self, path, file_id=None):
103
 
        """See MutableTree.mkdir()."""
104
 
        self.add(path, file_id, 'directory')
105
 
        if file_id is None:
106
 
            file_id = self.path2id(path)
107
 
        self._file_transport.mkdir(path)
108
 
        return file_id
109
 
 
110
 
    @needs_read_lock
111
 
    def last_revision(self):
112
 
        """See MutableTree.last_revision."""
113
 
        return self._branch_revision_id
114
 
 
115
 
    def lock_read(self):
116
 
        """Lock the memory tree for reading.
117
 
 
118
 
        This triggers population of data from the branch for its revision.
119
 
        """
120
 
        self._locks += 1
121
 
        try:
122
 
            if self._locks == 1:
123
 
                self.branch.lock_read()
124
 
                self._lock_mode = "r"
125
 
                self._populate_from_branch()
126
 
        except:
127
 
            self._locks -= 1
128
 
            raise
129
 
 
130
 
    def lock_tree_write(self):
131
 
        """See MutableTree.lock_tree_write()."""
132
 
        self._locks += 1
133
 
        try:
134
 
            if self._locks == 1:
135
 
                self.branch.lock_read()
136
 
                self._lock_mode = "w"
137
 
                self._populate_from_branch()
138
 
            elif self._lock_mode == "r":
139
 
                raise errors.ReadOnlyError(self)
140
 
        except:
141
 
            self._locks -= 1
142
 
            raise
143
 
 
144
 
    def lock_write(self):
145
 
        """See MutableTree.lock_write()."""
146
 
        self._locks += 1
147
 
        try:
148
 
            if self._locks == 1:
149
 
                self.branch.lock_write()
150
 
                self._lock_mode = "w"
151
 
                self._populate_from_branch()
152
 
            elif self._lock_mode == "r":
153
 
                raise errors.ReadOnlyError(self)
154
 
        except:
155
 
            self._locks -= 1
156
 
            raise
157
 
 
158
 
    def _populate_from_branch(self):
159
 
        """Populate the in-tree state from the branch."""
160
 
        self._basis_tree = self.branch.repository.revision_tree(
161
 
            self._branch_revision_id)
162
 
        if self._branch_revision_id is None:
163
 
            self._parent_ids = []
164
 
        else:
165
 
            self._parent_ids = [self._branch_revision_id]
166
 
        self._inventory = deepcopy(self._basis_tree._inventory)
167
 
        self._file_transport = MemoryTransport()
168
 
        # TODO copy the revision trees content, or do it lazy, or something.
169
 
        inventory_entries = self._inventory.iter_entries()
170
 
        inventory_entries.next()
171
 
        for path, entry in inventory_entries:
172
 
            if entry.kind == 'directory':
173
 
                self._file_transport.mkdir(path)
174
 
            elif entry.kind == 'file':
175
 
                self._file_transport.put_file(path,
176
 
                    self._basis_tree.get_file(entry.file_id))
177
 
            else:
178
 
                raise NotImplementedError(self._populate_from_branch)
179
 
 
180
 
    def put_file_bytes_non_atomic(self, file_id, bytes):
181
 
        """See MutableTree.put_file_bytes_non_atomic."""
182
 
        self._file_transport.put_bytes(self.id2path(file_id), bytes)
183
 
 
184
 
    def unlock(self):
185
 
        """Release a lock.
186
 
 
187
 
        This frees all cached state when the last lock context for the tree is
188
 
        left.
189
 
        """
190
 
        if self._locks == 1:
191
 
            self._basis_tree = None
192
 
            self._parent_ids = []
193
 
            self._inventory = None
194
 
            try:
195
 
                self.branch.unlock()
196
 
            finally:
197
 
                self._locks = 0
198
 
                self._lock_mode = None
199
 
        else:
200
 
            self._locks -= 1
201
 
 
202
 
    @needs_tree_write_lock
203
 
    def unversion(self, file_ids):
204
 
        """Remove the file ids in file_ids from the current versioned set.
205
 
 
206
 
        When a file_id is unversioned, all of its children are automatically
207
 
        unversioned.
208
 
 
209
 
        :param file_ids: The file ids to stop versioning.
210
 
        :raises: NoSuchId if any fileid is not currently versioned.
211
 
        """
212
 
        # XXX: This should be in mutabletree, but the inventory-save action
213
 
        # is not relevant to memory tree. Until that is done in unlock by
214
 
        # working tree, we cannot share the implementation.
215
 
        for file_id in file_ids:
216
 
            if self._inventory.has_id(file_id):
217
 
                self._inventory.remove_recursive_id(file_id)
218
 
            else:
219
 
                raise errors.NoSuchId(self, file_id)
220
 
 
221
 
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
222
 
        """See MutableTree.set_parent_trees()."""
223
 
        if len(parents_list) == 0:
224
 
            self._parent_ids = []
225
 
            self._basis_tree = self.branch.repository.revisiontree(None)
226
 
        else:
227
 
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
228
 
                # a ghost in the left most parent
229
 
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
230
 
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
231
 
            if parents_list[0][1] is None:
232
 
                self._basis_tree = self.branch.repository.revisiontree(None)
233
 
            else:
234
 
                self._basis_tree = parents_list[0][1]
235
 
            self._branch_revision_id = parents_list[0][0]