← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/memorytree.py

Exclude more files from dumb-rsync upload

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 kind(self, file_id):
103
 
        return self._inventory[file_id].kind
104
 
 
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
 
 
113
 
    @needs_read_lock
114
 
    def last_revision(self):
115
 
        """See MutableTree.last_revision."""
116
 
        return self._branch_revision_id
117
 
 
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
 
 
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
 
 
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:
174
 
            if path == '':
175
 
                continue
176
 
            if entry.kind == 'directory':
177
 
                self._file_transport.mkdir(path)
178
 
            elif entry.kind == 'file':
179
 
                self._file_transport.put_file(path,
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."""
186
 
        self._file_transport.put_bytes(self.id2path(file_id), bytes)
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
 
 
206
 
    @needs_tree_write_lock
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
 
 
225
 
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
226
 
        """See MutableTree.set_parent_trees()."""
227
 
        if len(revision_ids) == 0:
228
 
            self._parent_ids = []
229
 
            self._basis_tree = self.branch.repository.revision_tree(None)
230
 
        else:
231
 
            self._parent_ids = revision_ids
232
 
            self._basis_tree = self.branch.repository.revision_tree(
233
 
                                    revision_ids[0])
234
 
            self._branch_revision_id = revision_ids[0]
235
 
 
236
 
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
237
 
        """See MutableTree.set_parent_trees()."""
238
 
        if len(parents_list) == 0:
239
 
            self._parent_ids = []
240
 
            self._basis_tree = self.branch.repository.revision_tree(None)
241
 
        else:
242
 
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
243
 
                # a ghost in the left most parent
244
 
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
245
 
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
246
 
            if parents_list[0][1] is None:
247
 
                self._basis_tree = self.branch.repository.revision_tree(None)
248
 
            else:
249
 
                self._basis_tree = parents_list[0][1]
250
 
            self._branch_revision_id = parents_list[0][0]