/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: John Arbash Meinel
  • Date: 2009-06-02 21:11:18 UTC
  • mto: This revision was merged to the branch mainline in revision 4412.
  • Revision ID: john@arbash-meinel.com-20090602211118-fjsx4dxokahrqkrr
Change groupcompress.DeltaIndex to be lazy about indexing the first source.

This changes the performance characteristics of 'commit', especially of large files.
The main benefit is that during commit, we won't be doing any deltas as we add
all new content to a new group anyway.
Thus we know that we won't ever use the delta index we were creating, so
we can save both time and memory by never creating the index until it is
needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/revisiontree.py
 
1
# Copyright (C) 2005, 2007 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 cStringIO import StringIO
 
20
 
 
21
from bzrlib import (
 
22
    errors,
 
23
    osutils,
 
24
    revision,
 
25
    symbol_versioning,
 
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, branch, inv, revision_id):
 
37
        # for compatability the 'branch' parameter has not been renamed to
 
38
        # repository at this point. However, we should change RevisionTree's
 
39
        # construction to always be via Repository and not via direct
 
40
        # construction - this will mean that we can change the constructor
 
41
        # with much less chance of breaking client code.
 
42
        self._repository = branch
 
43
        self._inventory = inv
 
44
        self._revision_id = revision_id
 
45
        self._rules_searcher = None
 
46
 
 
47
    def supports_tree_reference(self):
 
48
        return getattr(self._repository._format, "supports_tree_reference",
 
49
            False)
 
50
 
 
51
    def get_parent_ids(self):
 
52
        """See Tree.get_parent_ids.
 
53
 
 
54
        A RevisionTree's parents match the revision graph.
 
55
        """
 
56
        if self._revision_id in (None, revision.NULL_REVISION):
 
57
            parent_ids = []
 
58
        else:
 
59
            parent_ids = self._repository.get_revision(
 
60
                self._revision_id).parent_ids
 
61
        return parent_ids
 
62
 
 
63
    def get_revision_id(self):
 
64
        """Return the revision id associated with this tree."""
 
65
        return self._revision_id
 
66
 
 
67
    def get_file_text(self, file_id, path=None):
 
68
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
 
69
        return ''.join(content)
 
70
 
 
71
    def get_file(self, file_id, path=None):
 
72
        return StringIO(self.get_file_text(file_id))
 
73
 
 
74
    def iter_files_bytes(self, desired_files):
 
75
        """See Tree.iter_files_bytes.
 
76
 
 
77
        This version is implemented on top of Repository.extract_files_bytes"""
 
78
        repo_desired_files = [(f, self.inventory[f].revision, i)
 
79
                              for f, i in desired_files]
 
80
        try:
 
81
            for result in self._repository.iter_files_bytes(repo_desired_files):
 
82
                yield result
 
83
        except errors.RevisionNotPresent, e:
 
84
            raise errors.NoSuchFile(e.revision_id)
 
85
 
 
86
    def annotate_iter(self, file_id,
 
87
                      default_revision=revision.CURRENT_REVISION):
 
88
        """See Tree.annotate_iter"""
 
89
        text_key = (file_id, self.inventory[file_id].revision)
 
90
        annotations = self._repository.texts.annotate(text_key)
 
91
        return [(key[-1], line) for key, line in annotations]
 
92
 
 
93
    def get_file_size(self, file_id):
 
94
        """See Tree.get_file_size"""
 
95
        return self._inventory[file_id].text_size
 
96
 
 
97
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
98
        ie = self._inventory[file_id]
 
99
        if ie.kind == "file":
 
100
            return ie.text_sha1
 
101
        return None
 
102
 
 
103
    def get_file_mtime(self, file_id, path=None):
 
104
        ie = self._inventory[file_id]
 
105
        revision = self._repository.get_revision(ie.revision)
 
106
        return revision.timestamp
 
107
 
 
108
    def is_executable(self, file_id, path=None):
 
109
        ie = self._inventory[file_id]
 
110
        if ie.kind != "file":
 
111
            return None
 
112
        return ie.executable
 
113
 
 
114
    def has_filename(self, filename):
 
115
        return bool(self.inventory.path2id(filename))
 
116
 
 
117
    def list_files(self, include_root=False):
 
118
        # The only files returned by this are those from the version
 
119
        entries = self.inventory.iter_entries()
 
120
        # skip the root for compatability with the current apis.
 
121
        if self.inventory.root is not None and not include_root:
 
122
            # skip the root for compatability with the current apis.
 
123
            entries.next()
 
124
        for path, entry in entries:
 
125
            yield path, 'V', entry.kind, entry.file_id, entry
 
126
 
 
127
    def get_symlink_target(self, file_id):
 
128
        ie = self._inventory[file_id]
 
129
        # Inventories store symlink targets in unicode
 
130
        return ie.symlink_target
 
131
 
 
132
    def get_reference_revision(self, file_id, path=None):
 
133
        return self.inventory[file_id].reference_revision
 
134
 
 
135
    def get_root_id(self):
 
136
        if self.inventory.root:
 
137
            return self.inventory.root.file_id
 
138
 
 
139
    def kind(self, file_id):
 
140
        return self._inventory[file_id].kind
 
141
 
 
142
    def path_content_summary(self, path):
 
143
        """See Tree.path_content_summary."""
 
144
        id = self.inventory.path2id(path)
 
145
        if id is None:
 
146
            return ('missing', None, None, None)
 
147
        entry = self._inventory[id]
 
148
        kind = entry.kind
 
149
        if kind == 'file':
 
150
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
 
151
        elif kind == 'symlink':
 
152
            return (kind, None, None, entry.symlink_target)
 
153
        else:
 
154
            return (kind, None, None, None)
 
155
 
 
156
    def _comparison_data(self, entry, path):
 
157
        if entry is None:
 
158
            return None, False, None
 
159
        return entry.kind, entry.executable, None
 
160
 
 
161
    def _file_size(self, entry, stat_value):
 
162
        return entry.text_size
 
163
 
 
164
    def _get_ancestors(self, default_revision):
 
165
        return set(self._repository.get_ancestry(self._revision_id,
 
166
                                                 topo_sorted=False))
 
167
 
 
168
    def lock_read(self):
 
169
        self._repository.lock_read()
 
170
 
 
171
    def __repr__(self):
 
172
        return '<%s instance at %x, rev_id=%r>' % (
 
173
            self.__class__.__name__, id(self), self._revision_id)
 
174
 
 
175
    def unlock(self):
 
176
        self._repository.unlock()
 
177
 
 
178
    def walkdirs(self, prefix=""):
 
179
        _directory = 'directory'
 
180
        inv = self.inventory
 
181
        top_id = inv.path2id(prefix)
 
182
        if top_id is None:
 
183
            pending = []
 
184
        else:
 
185
            pending = [(prefix, '', _directory, None, top_id, None)]
 
186
        while pending:
 
187
            dirblock = []
 
188
            currentdir = pending.pop()
 
189
            # 0 - relpath, 1- basename, 2- kind, 3- stat, id, v-kind
 
190
            if currentdir[0]:
 
191
                relroot = currentdir[0] + '/'
 
192
            else:
 
193
                relroot = ""
 
194
            # FIXME: stash the node in pending
 
195
            entry = inv[currentdir[4]]
 
196
            for name, child in entry.sorted_children():
 
197
                toppath = relroot + name
 
198
                dirblock.append((toppath, name, child.kind, None,
 
199
                    child.file_id, child.kind
 
200
                    ))
 
201
            yield (currentdir[0], entry.file_id), dirblock
 
202
            # push the user specified dirs from dirblock
 
203
            for dir in reversed(dirblock):
 
204
                if dir[2] == _directory:
 
205
                    pending.append(dir)
 
206
 
 
207
    def _get_rules_searcher(self, default_searcher):
 
208
        """See Tree._get_rules_searcher."""
 
209
        if self._rules_searcher is None:
 
210
            self._rules_searcher = super(RevisionTree,
 
211
                self)._get_rules_searcher(default_searcher)
 
212
        return self._rules_searcher
 
213
 
 
214
 
 
215
class InterCHKRevisionTree(tree.InterTree):
 
216
    """Fast path optimiser for RevisionTrees with CHK inventories."""
 
217
 
 
218
    @staticmethod
 
219
    def is_compatible(source, target):
 
220
        if (isinstance(source, RevisionTree)
 
221
            and isinstance(target, RevisionTree)):
 
222
            try:
 
223
                # Only CHK inventories have id_to_entry attribute
 
224
                source.inventory.id_to_entry
 
225
                target.inventory.id_to_entry
 
226
                return True
 
227
            except AttributeError:
 
228
                pass
 
229
        return False
 
230
 
 
231
    def iter_changes(self, include_unchanged=False,
 
232
                     specific_files=None, pb=None, extra_trees=[],
 
233
                     require_versioned=True, want_unversioned=False):
 
234
        lookup_trees = [self.source]
 
235
        if extra_trees:
 
236
             lookup_trees.extend(extra_trees)
 
237
        if specific_files == []:
 
238
            specific_file_ids = []
 
239
        else:
 
240
            specific_file_ids = self.target.paths2ids(specific_files,
 
241
                lookup_trees, require_versioned=require_versioned)
 
242
 
 
243
        # FIXME: It should be possible to delegate include_unchanged handling
 
244
        # to CHKInventory.iter_changes and do a better job there -- vila
 
245
        # 20090304
 
246
        if include_unchanged:
 
247
            changed_file_ids = []
 
248
        for result in self.target.inventory.iter_changes(self.source.inventory):
 
249
            if (specific_file_ids is not None
 
250
                and not result[0] in specific_file_ids):
 
251
                # CHKMap.iter_changes is clean and fast. Better filter out
 
252
                # the specific files *after* it did its job.
 
253
                continue
 
254
            yield result
 
255
            if include_unchanged:
 
256
                # Keep track of yielded results (cheaper than building the
 
257
                # whole inventory).
 
258
                changed_file_ids.append(result[0])
 
259
        if include_unchanged:
 
260
            # CHKMap avoid being O(tree), so we go to O(tree) only if
 
261
            # required to.
 
262
            # Now walk the whole inventory, excluding the already yielded
 
263
            # file ids
 
264
            changed_file_ids = set(changed_file_ids)
 
265
            for relpath, entry in self.target.inventory.iter_entries():
 
266
                if (specific_file_ids is not None
 
267
                    and not entry.file_id in specific_file_ids):
 
268
                    continue
 
269
                if not entry.file_id in changed_file_ids:
 
270
                    yield (entry.file_id,
 
271
                           (relpath, relpath), # Not renamed
 
272
                           False, # Not modified
 
273
                           (True, True), # Still  versioned
 
274
                           (entry.parent_id, entry.parent_id),
 
275
                           (entry.name, entry.name),
 
276
                           (entry.kind, entry.kind),
 
277
                           (entry.executable, entry.executable))
 
278
 
 
279
 
 
280
tree.InterTree.register_optimiser(InterCHKRevisionTree)