/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/revisiontree.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisiontree.py
 
1
# Copyright (C) 2006-2010 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""RevisionTree - a Tree implementation backed by repository data for a revision."""
 
18
 
 
19
from __future__ import absolute_import
 
20
 
 
21
from cStringIO import StringIO
 
22
 
 
23
from bzrlib import (
 
24
    errors,
 
25
    revision,
 
26
    tree,
 
27
    )
 
28
 
 
29
 
 
30
class RevisionTree(tree.Tree):
 
31
    """Tree viewing a previous revision.
 
32
 
 
33
    File text can be retrieved from the text store.
 
34
    """
 
35
 
 
36
    def __init__(self, repository, revision_id):
 
37
        self._repository = repository
 
38
        self._revision_id = revision_id
 
39
        self._rules_searcher = None
 
40
 
 
41
    def has_versioned_directories(self):
 
42
        """See `Tree.has_versioned_directories`."""
 
43
        return self._repository._format.supports_versioned_directories
 
44
 
 
45
    def supports_tree_reference(self):
 
46
        return getattr(self._repository._format, "supports_tree_reference",
 
47
            False)
 
48
 
 
49
    def get_parent_ids(self):
 
50
        """See Tree.get_parent_ids.
 
51
 
 
52
        A RevisionTree's parents match the revision graph.
 
53
        """
 
54
        if self._revision_id in (None, revision.NULL_REVISION):
 
55
            parent_ids = []
 
56
        else:
 
57
            parent_ids = self._repository.get_revision(
 
58
                self._revision_id).parent_ids
 
59
        return parent_ids
 
60
 
 
61
    def get_revision_id(self):
 
62
        """Return the revision id associated with this tree."""
 
63
        return self._revision_id
 
64
 
 
65
    def get_file_revision(self, file_id, path=None):
 
66
        """Return the revision id in which a file was last changed."""
 
67
        raise NotImplementedError(self.get_file_revision)
 
68
 
 
69
    def get_file_text(self, file_id, path=None):
 
70
        for (identifier, content) in self.iter_files_bytes([(file_id, None)]):
 
71
            ret = "".join(content)
 
72
        return ret
 
73
 
 
74
    def get_file(self, file_id, path=None):
 
75
        return StringIO(self.get_file_text(file_id))
 
76
 
 
77
    def is_locked(self):
 
78
        return self._repository.is_locked()
 
79
 
 
80
    def lock_read(self):
 
81
        self._repository.lock_read()
 
82
        return self
 
83
 
 
84
    def __repr__(self):
 
85
        return '<%s instance at %x, rev_id=%r>' % (
 
86
            self.__class__.__name__, id(self), self._revision_id)
 
87
 
 
88
    def unlock(self):
 
89
        self._repository.unlock()
 
90
 
 
91
    def _get_rules_searcher(self, default_searcher):
 
92
        """See Tree._get_rules_searcher."""
 
93
        if self._rules_searcher is None:
 
94
            self._rules_searcher = super(RevisionTree,
 
95
                self)._get_rules_searcher(default_searcher)
 
96
        return self._rules_searcher
 
97
 
 
98
 
 
99
class InventoryRevisionTree(RevisionTree,tree.InventoryTree):
 
100
 
 
101
    def __init__(self, repository, inv, revision_id):
 
102
        RevisionTree.__init__(self, repository, revision_id)
 
103
        self._inventory = inv
 
104
 
 
105
    def get_file_mtime(self, file_id, path=None):
 
106
        ie = self._inventory[file_id]
 
107
        try:
 
108
            revision = self._repository.get_revision(ie.revision)
 
109
        except errors.NoSuchRevision:
 
110
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
 
111
        return revision.timestamp
 
112
 
 
113
    def get_file_size(self, file_id):
 
114
        return self._inventory[file_id].text_size
 
115
 
 
116
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
117
        ie = self._inventory[file_id]
 
118
        if ie.kind == "file":
 
119
            return ie.text_sha1
 
120
        return None
 
121
 
 
122
    def get_file_revision(self, file_id, path=None):
 
123
        ie = self._inventory[file_id]
 
124
        return ie.revision
 
125
 
 
126
    def is_executable(self, file_id, path=None):
 
127
        ie = self._inventory[file_id]
 
128
        if ie.kind != "file":
 
129
            return False
 
130
        return ie.executable
 
131
 
 
132
    def has_filename(self, filename):
 
133
        return bool(self.inventory.path2id(filename))
 
134
 
 
135
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
136
        # The only files returned by this are those from the version
 
137
        inv = self.inventory
 
138
        if from_dir is None:
 
139
            from_dir_id = None
 
140
        else:
 
141
            from_dir_id = inv.path2id(from_dir)
 
142
            if from_dir_id is None:
 
143
                # Directory not versioned
 
144
                return
 
145
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
 
146
        if inv.root is not None and not include_root and from_dir is None:
 
147
            # skip the root for compatability with the current apis.
 
148
            entries.next()
 
149
        for path, entry in entries:
 
150
            yield path, 'V', entry.kind, entry.file_id, entry
 
151
 
 
152
    def get_symlink_target(self, file_id, path=None):
 
153
        ie = self._inventory[file_id]
 
154
        # Inventories store symlink targets in unicode
 
155
        return ie.symlink_target
 
156
 
 
157
    def get_reference_revision(self, file_id, path=None):
 
158
        return self.inventory[file_id].reference_revision
 
159
 
 
160
    def get_root_id(self):
 
161
        if self.inventory.root:
 
162
            return self.inventory.root.file_id
 
163
 
 
164
    def kind(self, file_id):
 
165
        return self._inventory[file_id].kind
 
166
 
 
167
    def path_content_summary(self, path):
 
168
        """See Tree.path_content_summary."""
 
169
        id = self.inventory.path2id(path)
 
170
        if id is None:
 
171
            return ('missing', None, None, None)
 
172
        entry = self._inventory[id]
 
173
        kind = entry.kind
 
174
        if kind == 'file':
 
175
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
 
176
        elif kind == 'symlink':
 
177
            return (kind, None, None, entry.symlink_target)
 
178
        else:
 
179
            return (kind, None, None, None)
 
180
 
 
181
    def _comparison_data(self, entry, path):
 
182
        if entry is None:
 
183
            return None, False, None
 
184
        return entry.kind, entry.executable, None
 
185
 
 
186
    def _file_size(self, entry, stat_value):
 
187
        return entry.text_size
 
188
 
 
189
    def walkdirs(self, prefix=""):
 
190
        _directory = 'directory'
 
191
        inv = self.inventory
 
192
        top_id = inv.path2id(prefix)
 
193
        if top_id is None:
 
194
            pending = []
 
195
        else:
 
196
            pending = [(prefix, '', _directory, None, top_id, None)]
 
197
        while pending:
 
198
            dirblock = []
 
199
            currentdir = pending.pop()
 
200
            # 0 - relpath, 1- basename, 2- kind, 3- stat, id, v-kind
 
201
            if currentdir[0]:
 
202
                relroot = currentdir[0] + '/'
 
203
            else:
 
204
                relroot = ""
 
205
            # FIXME: stash the node in pending
 
206
            entry = inv[currentdir[4]]
 
207
            for name, child in entry.sorted_children():
 
208
                toppath = relroot + name
 
209
                dirblock.append((toppath, name, child.kind, None,
 
210
                    child.file_id, child.kind
 
211
                    ))
 
212
            yield (currentdir[0], entry.file_id), dirblock
 
213
            # push the user specified dirs from dirblock
 
214
            for dir in reversed(dirblock):
 
215
                if dir[2] == _directory:
 
216
                    pending.append(dir)
 
217
 
 
218
    def iter_files_bytes(self, desired_files):
 
219
        """See Tree.iter_files_bytes.
 
220
 
 
221
        This version is implemented on top of Repository.iter_files_bytes"""
 
222
        repo_desired_files = [(f, self.get_file_revision(f), i)
 
223
                              for f, i in desired_files]
 
224
        try:
 
225
            for result in self._repository.iter_files_bytes(repo_desired_files):
 
226
                yield result
 
227
        except errors.RevisionNotPresent, e:
 
228
            raise errors.NoSuchFile(e.file_id)
 
229
 
 
230
    def annotate_iter(self, file_id,
 
231
                      default_revision=revision.CURRENT_REVISION):
 
232
        """See Tree.annotate_iter"""
 
233
        text_key = (file_id, self.get_file_revision(file_id))
 
234
        annotator = self._repository.texts.get_annotator()
 
235
        annotations = annotator.annotate_flat(text_key)
 
236
        return [(key[-1], line) for key, line in annotations]
 
237
 
 
238
 
 
239
class InterCHKRevisionTree(tree.InterTree):
 
240
    """Fast path optimiser for RevisionTrees with CHK inventories."""
 
241
 
 
242
    @staticmethod
 
243
    def is_compatible(source, target):
 
244
        if (isinstance(source, RevisionTree)
 
245
            and isinstance(target, RevisionTree)):
 
246
            try:
 
247
                # Only CHK inventories have id_to_entry attribute
 
248
                source.inventory.id_to_entry
 
249
                target.inventory.id_to_entry
 
250
                return True
 
251
            except AttributeError:
 
252
                pass
 
253
        return False
 
254
 
 
255
    def iter_changes(self, include_unchanged=False,
 
256
                     specific_files=None, pb=None, extra_trees=[],
 
257
                     require_versioned=True, want_unversioned=False):
 
258
        lookup_trees = [self.source]
 
259
        if extra_trees:
 
260
             lookup_trees.extend(extra_trees)
 
261
        # The ids of items we need to examine to insure delta consistency.
 
262
        precise_file_ids = set()
 
263
        discarded_changes = {}
 
264
        if specific_files == []:
 
265
            specific_file_ids = []
 
266
        else:
 
267
            specific_file_ids = self.target.paths2ids(specific_files,
 
268
                lookup_trees, require_versioned=require_versioned)
 
269
        # FIXME: It should be possible to delegate include_unchanged handling
 
270
        # to CHKInventory.iter_changes and do a better job there -- vila
 
271
        # 20090304
 
272
        changed_file_ids = set()
 
273
        for result in self.target.inventory.iter_changes(self.source.inventory):
 
274
            if specific_file_ids is not None:
 
275
                file_id = result[0]
 
276
                if file_id not in specific_file_ids:
 
277
                    # A change from the whole tree that we don't want to show yet.
 
278
                    # We may find that we need to show it for delta consistency, so
 
279
                    # stash it.
 
280
                    discarded_changes[result[0]] = result
 
281
                    continue
 
282
                new_parent_id = result[4][1]
 
283
                precise_file_ids.add(new_parent_id)
 
284
            yield result
 
285
            changed_file_ids.add(result[0])
 
286
        if specific_file_ids is not None:
 
287
            for result in self._handle_precise_ids(precise_file_ids,
 
288
                changed_file_ids, discarded_changes=discarded_changes):
 
289
                yield result
 
290
        if include_unchanged:
 
291
            # CHKMap avoid being O(tree), so we go to O(tree) only if
 
292
            # required to.
 
293
            # Now walk the whole inventory, excluding the already yielded
 
294
            # file ids
 
295
            changed_file_ids = set(changed_file_ids)
 
296
            for relpath, entry in self.target.inventory.iter_entries():
 
297
                if (specific_file_ids is not None
 
298
                    and not entry.file_id in specific_file_ids):
 
299
                    continue
 
300
                if not entry.file_id in changed_file_ids:
 
301
                    yield (entry.file_id,
 
302
                           (relpath, relpath), # Not renamed
 
303
                           False, # Not modified
 
304
                           (True, True), # Still  versioned
 
305
                           (entry.parent_id, entry.parent_id),
 
306
                           (entry.name, entry.name),
 
307
                           (entry.kind, entry.kind),
 
308
                           (entry.executable, entry.executable))
 
309
 
 
310
 
 
311
tree.InterTree.register_optimiser(InterCHKRevisionTree)