/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: James Westby
  • Date: 2007-09-18 18:55:00 UTC
  • mto: (2866.1.1 james.westby)
  • mto: This revision was merged to the branch mainline in revision 2867.
  • Revision ID: jw+debian@jameswestby.net-20070918185500-91alkjx8zolds1v8
Fix log against smart server branches that don't support tags. (#140615)

Add get_reverse_tag_dict to DisabledTags for branches that falsely
claim that they support tags (namely smart server branches). When the
remote branch was an old format without tags this caused log to fail.

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