/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/memorytree.py

  • Committer: Robert Collins
  • Date: 2007-08-08 02:57:22 UTC
  • mto: This revision was merged to the branch mainline in revision 2687.
  • Revision ID: robertc@robertcollins.net-20070808025722-26wvnolkzmnse7s1
* The ``bzrlib.pack`` interface has changed to use tuples of bytestrings
  rather than just bytestrings, making it easier to represent multiple
  element names. As this interface was not used by any internal facilities
  since it was introduced in 0.18 no API compatibility is being preserved.
  The serialised form of these packs is identical with 0.18 when a single
  element tuple is in use. (Robert Collins)

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 (
 
26
    errors,
 
27
    mutabletree,
 
28
    revision as _mod_revision,
 
29
    )
 
30
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
31
from bzrlib.osutils import sha_file
 
32
from bzrlib.mutabletree import needs_tree_write_lock
 
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
 
 
52
    @needs_tree_write_lock
 
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."""
 
70
        revision_id = _mod_revision.ensure_null(branch.last_revision())
 
71
        if _mod_revision.is_null(revision_id):
 
72
            revision_id = None
 
73
        return MemoryTree(branch, revision_id)
 
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
 
 
82
    def get_file(self, file_id):
 
83
        """See Tree.get_file."""
 
84
        return self._file_transport.get(self.id2path(file_id))
 
85
 
 
86
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
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
 
 
93
    def _comparison_data(self, entry, path):
 
94
        """See Tree._comparison_data."""
 
95
        if entry is None:
 
96
            return None, False, None
 
97
        return entry.kind, entry.executable, None
 
98
 
 
99
    def _file_size(self, entry, stat_value):
 
100
        """See Tree._file_size."""
 
101
        if entry is None:
 
102
            return 0
 
103
        return entry.text_size
 
104
 
 
105
    @needs_read_lock
 
106
    def get_parent_ids(self):
 
107
        """See Tree.get_parent_ids.
 
108
 
 
109
        This implementation returns the current cached value from
 
110
            self._parent_ids.
 
111
        """
 
112
        return list(self._parent_ids)
 
113
 
 
114
    def has_filename(self, filename):
 
115
        """See Tree.has_filename()."""
 
116
        return self._file_transport.has(filename)
 
117
 
 
118
    def is_executable(self, file_id, path=None):
 
119
        return self._inventory[file_id].executable
 
120
 
 
121
    def kind(self, file_id):
 
122
        return self._inventory[file_id].kind
 
123
 
 
124
    def mkdir(self, path, file_id=None):
 
125
        """See MutableTree.mkdir()."""
 
126
        self.add(path, file_id, 'directory')
 
127
        if file_id is None:
 
128
            file_id = self.path2id(path)
 
129
        self._file_transport.mkdir(path)
 
130
        return file_id
 
131
 
 
132
    @needs_read_lock
 
133
    def last_revision(self):
 
134
        """See MutableTree.last_revision."""
 
135
        return self._branch_revision_id
 
136
 
 
137
    def lock_read(self):
 
138
        """Lock the memory tree for reading.
 
139
 
 
140
        This triggers population of data from the branch for its revision.
 
141
        """
 
142
        self._locks += 1
 
143
        try:
 
144
            if self._locks == 1:
 
145
                self.branch.lock_read()
 
146
                self._lock_mode = "r"
 
147
                self._populate_from_branch()
 
148
        except:
 
149
            self._locks -= 1
 
150
            raise
 
151
 
 
152
    def lock_tree_write(self):
 
153
        """See MutableTree.lock_tree_write()."""
 
154
        self._locks += 1
 
155
        try:
 
156
            if self._locks == 1:
 
157
                self.branch.lock_read()
 
158
                self._lock_mode = "w"
 
159
                self._populate_from_branch()
 
160
            elif self._lock_mode == "r":
 
161
                raise errors.ReadOnlyError(self)
 
162
        except:
 
163
            self._locks -= 1
 
164
            raise
 
165
 
 
166
    def lock_write(self):
 
167
        """See MutableTree.lock_write()."""
 
168
        self._locks += 1
 
169
        try:
 
170
            if self._locks == 1:
 
171
                self.branch.lock_write()
 
172
                self._lock_mode = "w"
 
173
                self._populate_from_branch()
 
174
            elif self._lock_mode == "r":
 
175
                raise errors.ReadOnlyError(self)
 
176
        except:
 
177
            self._locks -= 1
 
178
            raise
 
179
 
 
180
    def _populate_from_branch(self):
 
181
        """Populate the in-tree state from the branch."""
 
182
        self._basis_tree = self.branch.repository.revision_tree(
 
183
            self._branch_revision_id)
 
184
        if self._branch_revision_id is None:
 
185
            self._parent_ids = []
 
186
        else:
 
187
            self._parent_ids = [self._branch_revision_id]
 
188
        self._inventory = deepcopy(self._basis_tree._inventory)
 
189
        self._file_transport = MemoryTransport()
 
190
        # TODO copy the revision trees content, or do it lazy, or something.
 
191
        inventory_entries = self._inventory.iter_entries()
 
192
        for path, entry in inventory_entries:
 
193
            if path == '':
 
194
                continue
 
195
            if entry.kind == 'directory':
 
196
                self._file_transport.mkdir(path)
 
197
            elif entry.kind == 'file':
 
198
                self._file_transport.put_file(path,
 
199
                    self._basis_tree.get_file(entry.file_id))
 
200
            else:
 
201
                raise NotImplementedError(self._populate_from_branch)
 
202
 
 
203
    def put_file_bytes_non_atomic(self, file_id, bytes):
 
204
        """See MutableTree.put_file_bytes_non_atomic."""
 
205
        self._file_transport.put_bytes(self.id2path(file_id), bytes)
 
206
 
 
207
    def unlock(self):
 
208
        """Release a lock.
 
209
 
 
210
        This frees all cached state when the last lock context for the tree is
 
211
        left.
 
212
        """
 
213
        if self._locks == 1:
 
214
            self._basis_tree = None
 
215
            self._parent_ids = []
 
216
            self._inventory = None
 
217
            try:
 
218
                self.branch.unlock()
 
219
            finally:
 
220
                self._locks = 0
 
221
                self._lock_mode = None
 
222
        else:
 
223
            self._locks -= 1
 
224
 
 
225
    @needs_tree_write_lock
 
226
    def unversion(self, file_ids):
 
227
        """Remove the file ids in file_ids from the current versioned set.
 
228
 
 
229
        When a file_id is unversioned, all of its children are automatically
 
230
        unversioned.
 
231
 
 
232
        :param file_ids: The file ids to stop versioning.
 
233
        :raises: NoSuchId if any fileid is not currently versioned.
 
234
        """
 
235
        # XXX: This should be in mutabletree, but the inventory-save action
 
236
        # is not relevant to memory tree. Until that is done in unlock by
 
237
        # working tree, we cannot share the implementation.
 
238
        for file_id in file_ids:
 
239
            if self._inventory.has_id(file_id):
 
240
                self._inventory.remove_recursive_id(file_id)
 
241
            else:
 
242
                raise errors.NoSuchId(self, file_id)
 
243
 
 
244
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
245
        """See MutableTree.set_parent_trees()."""
 
246
        for revision_id in revision_ids:
 
247
            _mod_revision.check_not_reserved_id(revision_id)
 
248
        if len(revision_ids) == 0:
 
249
            self._parent_ids = []
 
250
            self._basis_tree = self.branch.repository.revision_tree(None)
 
251
        else:
 
252
            self._parent_ids = revision_ids
 
253
            self._basis_tree = self.branch.repository.revision_tree(
 
254
                                    revision_ids[0])
 
255
            self._branch_revision_id = revision_ids[0]
 
256
 
 
257
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
258
        """See MutableTree.set_parent_trees()."""
 
259
        if len(parents_list) == 0:
 
260
            self._parent_ids = []
 
261
            self._basis_tree = self.branch.repository.revision_tree(None)
 
262
        else:
 
263
            if parents_list[0][1] is None and not allow_leftmost_as_ghost:
 
264
                # a ghost in the left most parent
 
265
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
 
266
            self._parent_ids = [parent_id for parent_id, tree in parents_list]
 
267
            if parents_list[0][1] is None or parents_list[0][1] == 'null:':
 
268
                import pdb; pdb.set_trace()
 
269
                self._basis_tree = self.branch.repository.revision_tree(None)
 
270
            else:
 
271
                self._basis_tree = parents_list[0][1]
 
272
            self._branch_revision_id = parents_list[0][0]