← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-16 16:58:03 UTC
  • mfrom: (3224.3.1 news-typo)
  • Revision ID: pqm@pqm.ubuntu.com-20080316165803-tisoc9mpob9z544o
(Matt Nordhoff) Trivial NEWS typo fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from cStringIO import StringIO
16
18
 
17
19
from bzrlib.lazy_import import lazy_import
18
20
lazy_import(globals(), """
19
 
import itertools
 
21
import re
20
22
import time
21
23
 
22
24
from bzrlib import (
23
25
    bzrdir,
24
 
    config,
25
 
    controldir,
 
26
    check,
26
27
    debug,
 
28
    deprecated_graph,
 
29
    errors,
27
30
    generate_ids,
 
31
    gpg,
28
32
    graph,
 
33
    lazy_regex,
29
34
    lockable_files,
30
35
    lockdir,
 
36
    lru_cache,
31
37
    osutils,
 
38
    registry,
 
39
    remote,
32
40
    revision as _mod_revision,
33
 
    testament as _mod_testament,
 
41
    symbol_versioning,
 
42
    transactions,
34
43
    tsort,
35
 
    gpg,
 
44
    ui,
36
45
    )
37
46
from bzrlib.bundle import serializer
38
 
from bzrlib.i18n import gettext
 
47
from bzrlib.revisiontree import RevisionTree
 
48
from bzrlib.store.versioned import VersionedFileStore
 
49
from bzrlib.store.text import TextStore
 
50
from bzrlib.testament import Testament
 
51
from bzrlib.util import bencode
39
52
""")
40
53
 
41
 
from bzrlib import (
42
 
    errors,
43
 
    registry,
44
 
    symbol_versioning,
45
 
    ui,
46
 
    )
47
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
54
from bzrlib.decorators import needs_read_lock, needs_write_lock
48
55
from bzrlib.inter import InterObject
49
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
50
 
from bzrlib.trace import (
51
 
    log_exception_quietly, note, mutter, mutter_callsite, warning)
 
56
from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID
 
57
from bzrlib.symbol_versioning import (
 
58
        deprecated_method,
 
59
        )
 
60
from bzrlib.trace import mutter, mutter_callsite, note, warning
52
61
 
53
62
 
54
63
# Old formats display a warning, but only once
55
64
_deprecation_warning_done = False
56
65
 
57
66
 
58
 
class IsInWriteGroupError(errors.InternalBzrError):
59
 
 
60
 
    _fmt = "May not refresh_data of repo %(repo)s while in a write group."
61
 
 
62
 
    def __init__(self, repo):
63
 
        errors.InternalBzrError.__init__(self, repo=repo)
64
 
 
65
 
 
66
67
class CommitBuilder(object):
67
68
    """Provides an interface to build up a commit.
68
69
 
69
 
    This allows describing a tree to be committed without needing to
 
70
    This allows describing a tree to be committed without needing to 
70
71
    know the internals of the format of the repository.
71
72
    """
72
 
 
 
73
    
73
74
    # all clients should supply tree roots.
74
75
    record_root_entry = True
75
 
    # whether this commit builder supports the record_entry_contents interface
76
 
    supports_record_entry_contents = False
 
76
    # the default CommitBuilder does not manage trees whose root is versioned.
 
77
    _versioned_root = False
77
78
 
78
79
    def __init__(self, repository, parents, config, timestamp=None,
79
80
                 timezone=None, committer=None, revprops=None,
80
 
                 revision_id=None, lossy=False):
 
81
                 revision_id=None):
81
82
        """Initiate a CommitBuilder.
82
83
 
83
84
        :param repository: Repository to commit to.
84
85
        :param parents: Revision ids of the parents of the new revision.
 
86
        :param config: Configuration to use.
85
87
        :param timestamp: Optional timestamp recorded for commit.
86
88
        :param timezone: Optional timezone for timestamp.
87
89
        :param committer: Optional committer to set for commit.
88
90
        :param revprops: Optional dictionary of revision properties.
89
91
        :param revision_id: Optional revision id.
90
 
        :param lossy: Whether to discard data that can not be natively
91
 
            represented, when pushing to a foreign VCS 
92
92
        """
93
93
        self._config = config
94
 
        self._lossy = lossy
95
94
 
96
95
        if committer is None:
97
96
            self._committer = self._config.username()
98
 
        elif not isinstance(committer, unicode):
99
 
            self._committer = committer.decode() # throw if non-ascii
100
97
        else:
 
98
            assert isinstance(committer, basestring), type(committer)
101
99
            self._committer = committer
102
100
 
 
101
        self.new_inventory = Inventory(None)
103
102
        self._new_revision_id = revision_id
104
103
        self.parents = parents
105
104
        self.repository = repository
106
105
 
107
106
        self._revprops = {}
108
107
        if revprops is not None:
109
 
            self._validate_revprops(revprops)
110
108
            self._revprops.update(revprops)
111
109
 
112
110
        if timestamp is None:
120
118
            self._timezone = int(timezone)
121
119
 
122
120
        self._generate_revision_if_needed()
123
 
 
124
 
    def any_changes(self):
125
 
        """Return True if any entries were changed.
126
 
 
127
 
        This includes merge-only changes. It is the core for the --unchanged
128
 
        detection in commit.
129
 
 
130
 
        :return: True if any changes have occured.
131
 
        """
132
 
        raise NotImplementedError(self.any_changes)
133
 
 
134
 
    def _validate_unicode_text(self, text, context):
135
 
        """Verify things like commit messages don't have bogus characters."""
136
 
        if '\r' in text:
137
 
            raise ValueError('Invalid value for %s: %r' % (context, text))
138
 
 
139
 
    def _validate_revprops(self, revprops):
140
 
        for key, value in revprops.iteritems():
141
 
            # We know that the XML serializers do not round trip '\r'
142
 
            # correctly, so refuse to accept them
143
 
            if not isinstance(value, basestring):
144
 
                raise ValueError('revision property (%s) is not a valid'
145
 
                                 ' (unicode) string: %r' % (key, value))
146
 
            self._validate_unicode_text(value,
147
 
                                        'revision property (%s)' % (key,))
 
121
        self.__heads = graph.HeadsCache(repository.get_graph()).heads
148
122
 
149
123
    def commit(self, message):
150
124
        """Make the actual commit.
151
125
 
152
126
        :return: The revision id of the recorded revision.
153
127
        """
154
 
        raise NotImplementedError(self.commit)
 
128
        rev = _mod_revision.Revision(
 
129
                       timestamp=self._timestamp,
 
130
                       timezone=self._timezone,
 
131
                       committer=self._committer,
 
132
                       message=message,
 
133
                       inventory_sha1=self.inv_sha1,
 
134
                       revision_id=self._new_revision_id,
 
135
                       properties=self._revprops)
 
136
        rev.parent_ids = self.parents
 
137
        self.repository.add_revision(self._new_revision_id, rev,
 
138
            self.new_inventory, self._config)
 
139
        self.repository.commit_write_group()
 
140
        return self._new_revision_id
155
141
 
156
142
    def abort(self):
157
143
        """Abort the commit that is being built.
158
144
        """
159
 
        raise NotImplementedError(self.abort)
 
145
        self.repository.abort_write_group()
160
146
 
161
147
    def revision_tree(self):
162
148
        """Return the tree that was just committed.
163
149
 
164
 
        After calling commit() this can be called to get a
165
 
        RevisionTree representing the newly committed tree. This is
166
 
        preferred to calling Repository.revision_tree() because that may
167
 
        require deserializing the inventory, while we already have a copy in
 
150
        After calling commit() this can be called to get a RevisionTree
 
151
        representing the newly committed tree. This is preferred to
 
152
        calling Repository.revision_tree() because that may require
 
153
        deserializing the inventory, while we already have a copy in
168
154
        memory.
169
155
        """
170
 
        raise NotImplementedError(self.revision_tree)
 
156
        return RevisionTree(self.repository, self.new_inventory,
 
157
                            self._new_revision_id)
171
158
 
172
159
    def finish_inventory(self):
173
 
        """Tell the builder that the inventory is finished.
174
 
 
175
 
        :return: The inventory id in the repository, which can be used with
176
 
            repository.get_inventory.
177
 
        """
178
 
        raise NotImplementedError(self.finish_inventory)
 
160
        """Tell the builder that the inventory is finished."""
 
161
        if self.new_inventory.root is None:
 
162
            raise AssertionError('Root entry should be supplied to'
 
163
                ' record_entry_contents, as of bzr 0.10.',
 
164
                 DeprecationWarning, stacklevel=2)
 
165
            self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
 
166
        self.new_inventory.revision_id = self._new_revision_id
 
167
        self.inv_sha1 = self.repository.add_inventory(
 
168
            self._new_revision_id,
 
169
            self.new_inventory,
 
170
            self.parents
 
171
            )
179
172
 
180
173
    def _gen_revision_id(self):
181
174
        """Return new revision-id."""
182
 
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
 
175
        return generate_ids.gen_revision_id(self._config.username(),
 
176
                                            self._timestamp)
183
177
 
184
178
    def _generate_revision_if_needed(self):
185
179
        """Create a revision id if None was supplied.
186
 
 
 
180
        
187
181
        If the repository can not support user-specified revision ids
188
182
        they should override this function and raise CannotSetRevisionId
189
183
        if _new_revision_id is not None.
196
190
        else:
197
191
            self.random_revid = False
198
192
 
199
 
    def will_record_deletes(self):
200
 
        """Tell the commit builder that deletes are being notified.
201
 
 
202
 
        This enables the accumulation of an inventory delta; for the resulting
203
 
        commit to be valid, deletes against the basis MUST be recorded via
204
 
        builder.record_delete().
205
 
        """
206
 
        raise NotImplementedError(self.will_record_deletes)
207
 
 
208
 
    def record_iter_changes(self, tree, basis_revision_id, iter_changes):
209
 
        """Record a new tree via iter_changes.
210
 
 
211
 
        :param tree: The tree to obtain text contents from for changed objects.
212
 
        :param basis_revision_id: The revision id of the tree the iter_changes
213
 
            has been generated against. Currently assumed to be the same
214
 
            as self.parents[0] - if it is not, errors may occur.
215
 
        :param iter_changes: An iter_changes iterator with the changes to apply
216
 
            to basis_revision_id. The iterator must not include any items with
217
 
            a current kind of None - missing items must be either filtered out
218
 
            or errored-on beefore record_iter_changes sees the item.
219
 
        :return: A generator of (file_id, relpath, fs_hash) tuples for use with
220
 
            tree._observed_sha1.
221
 
        """
222
 
        raise NotImplementedError(self.record_iter_changes)
223
 
 
224
 
 
225
 
class RepositoryWriteLockResult(LogicalLockResult):
226
 
    """The result of write locking a repository.
227
 
 
228
 
    :ivar repository_token: The token obtained from the underlying lock, or
229
 
        None.
230
 
    :ivar unlock: A callable which will unlock the lock.
231
 
    """
232
 
 
233
 
    def __init__(self, unlock, repository_token):
234
 
        LogicalLockResult.__init__(self, unlock)
235
 
        self.repository_token = repository_token
236
 
 
237
 
    def __repr__(self):
238
 
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
239
 
            self.unlock)
 
193
    def _heads(self, file_id, revision_ids):
 
194
        """Calculate the graph heads for revision_ids in the graph of file_id.
 
195
 
 
196
        This can use either a per-file graph or a global revision graph as we
 
197
        have an identity relationship between the two graphs.
 
198
        """
 
199
        return self.__heads(revision_ids)
 
200
 
 
201
    def _check_root(self, ie, parent_invs, tree):
 
202
        """Helper for record_entry_contents.
 
203
 
 
204
        :param ie: An entry being added.
 
205
        :param parent_invs: The inventories of the parent revisions of the
 
206
            commit.
 
207
        :param tree: The tree that is being committed.
 
208
        """
 
209
        # In this revision format, root entries have no knit or weave When
 
210
        # serializing out to disk and back in root.revision is always
 
211
        # _new_revision_id
 
212
        ie.revision = self._new_revision_id
 
213
 
 
214
    def _get_delta(self, ie, basis_inv, path):
 
215
        """Get a delta against the basis inventory for ie."""
 
216
        if ie.file_id not in basis_inv:
 
217
            # add
 
218
            return (None, path, ie.file_id, ie)
 
219
        elif ie != basis_inv[ie.file_id]:
 
220
            # common but altered
 
221
            # TODO: avoid tis id2path call.
 
222
            return (basis_inv.id2path(ie.file_id), path, ie.file_id, ie)
 
223
        else:
 
224
            # common, unaltered
 
225
            return None
 
226
 
 
227
    def record_entry_contents(self, ie, parent_invs, path, tree,
 
228
        content_summary):
 
229
        """Record the content of ie from tree into the commit if needed.
 
230
 
 
231
        Side effect: sets ie.revision when unchanged
 
232
 
 
233
        :param ie: An inventory entry present in the commit.
 
234
        :param parent_invs: The inventories of the parent revisions of the
 
235
            commit.
 
236
        :param path: The path the entry is at in the tree.
 
237
        :param tree: The tree which contains this entry and should be used to 
 
238
            obtain content.
 
239
        :param content_summary: Summary data from the tree about the paths
 
240
            content - stat, length, exec, sha/link target. This is only
 
241
            accessed when the entry has a revision of None - that is when it is
 
242
            a candidate to commit.
 
243
        :return: A tuple (change_delta, version_recorded). change_delta is 
 
244
            an inventory_delta change for this entry against the basis tree of
 
245
            the commit, or None if no change occured against the basis tree.
 
246
            version_recorded is True if a new version of the entry has been
 
247
            recorded. For instance, committing a merge where a file was only
 
248
            changed on the other side will return (delta, False).
 
249
        """
 
250
        if self.new_inventory.root is None:
 
251
            if ie.parent_id is not None:
 
252
                raise errors.RootMissing()
 
253
            self._check_root(ie, parent_invs, tree)
 
254
        if ie.revision is None:
 
255
            kind = content_summary[0]
 
256
        else:
 
257
            # ie is carried over from a prior commit
 
258
            kind = ie.kind
 
259
        # XXX: repository specific check for nested tree support goes here - if
 
260
        # the repo doesn't want nested trees we skip it ?
 
261
        if (kind == 'tree-reference' and
 
262
            not self.repository._format.supports_tree_reference):
 
263
            # mismatch between commit builder logic and repository:
 
264
            # this needs the entry creation pushed down into the builder.
 
265
            raise NotImplementedError('Missing repository subtree support.')
 
266
        self.new_inventory.add(ie)
 
267
 
 
268
        # TODO: slow, take it out of the inner loop.
 
269
        try:
 
270
            basis_inv = parent_invs[0]
 
271
        except IndexError:
 
272
            basis_inv = Inventory(root_id=None)
 
273
 
 
274
        # ie.revision is always None if the InventoryEntry is considered
 
275
        # for committing. We may record the previous parents revision if the
 
276
        # content is actually unchanged against a sole head.
 
277
        if ie.revision is not None:
 
278
            if not self._versioned_root and path == '':
 
279
                # repositories that do not version the root set the root's
 
280
                # revision to the new commit even when no change occurs, and
 
281
                # this masks when a change may have occurred against the basis,
 
282
                # so calculate if one happened.
 
283
                if ie.file_id in basis_inv:
 
284
                    delta = (basis_inv.id2path(ie.file_id), path,
 
285
                        ie.file_id, ie)
 
286
                else:
 
287
                    # add
 
288
                    delta = (None, path, ie.file_id, ie)
 
289
                return delta, False
 
290
            else:
 
291
                # we don't need to commit this, because the caller already
 
292
                # determined that an existing revision of this file is
 
293
                # appropriate.
 
294
                return None, (ie.revision == self._new_revision_id)
 
295
        # XXX: Friction: parent_candidates should return a list not a dict
 
296
        #      so that we don't have to walk the inventories again.
 
297
        parent_candiate_entries = ie.parent_candidates(parent_invs)
 
298
        head_set = self._heads(ie.file_id, parent_candiate_entries.keys())
 
299
        heads = []
 
300
        for inv in parent_invs:
 
301
            if ie.file_id in inv:
 
302
                old_rev = inv[ie.file_id].revision
 
303
                if old_rev in head_set:
 
304
                    heads.append(inv[ie.file_id].revision)
 
305
                    head_set.remove(inv[ie.file_id].revision)
 
306
 
 
307
        store = False
 
308
        # now we check to see if we need to write a new record to the
 
309
        # file-graph.
 
310
        # We write a new entry unless there is one head to the ancestors, and
 
311
        # the kind-derived content is unchanged.
 
312
 
 
313
        # Cheapest check first: no ancestors, or more the one head in the
 
314
        # ancestors, we write a new node.
 
315
        if len(heads) != 1:
 
316
            store = True
 
317
        if not store:
 
318
            # There is a single head, look it up for comparison
 
319
            parent_entry = parent_candiate_entries[heads[0]]
 
320
            # if the non-content specific data has changed, we'll be writing a
 
321
            # node:
 
322
            if (parent_entry.parent_id != ie.parent_id or
 
323
                parent_entry.name != ie.name):
 
324
                store = True
 
325
        # now we need to do content specific checks:
 
326
        if not store:
 
327
            # if the kind changed the content obviously has
 
328
            if kind != parent_entry.kind:
 
329
                store = True
 
330
        if kind == 'file':
 
331
            assert content_summary[2] is not None, \
 
332
                "Files must not have executable = None"
 
333
            if not store:
 
334
                if (# if the file length changed we have to store:
 
335
                    parent_entry.text_size != content_summary[1] or
 
336
                    # if the exec bit has changed we have to store:
 
337
                    parent_entry.executable != content_summary[2]):
 
338
                    store = True
 
339
                elif parent_entry.text_sha1 == content_summary[3]:
 
340
                    # all meta and content is unchanged (using a hash cache
 
341
                    # hit to check the sha)
 
342
                    ie.revision = parent_entry.revision
 
343
                    ie.text_size = parent_entry.text_size
 
344
                    ie.text_sha1 = parent_entry.text_sha1
 
345
                    ie.executable = parent_entry.executable
 
346
                    return self._get_delta(ie, basis_inv, path), False
 
347
                else:
 
348
                    # Either there is only a hash change(no hash cache entry,
 
349
                    # or same size content change), or there is no change on
 
350
                    # this file at all.
 
351
                    # Provide the parent's hash to the store layer, so that the
 
352
                    # content is unchanged we will not store a new node.
 
353
                    nostore_sha = parent_entry.text_sha1
 
354
            if store:
 
355
                # We want to record a new node regardless of the presence or
 
356
                # absence of a content change in the file.
 
357
                nostore_sha = None
 
358
            ie.executable = content_summary[2]
 
359
            lines = tree.get_file(ie.file_id, path).readlines()
 
360
            try:
 
361
                ie.text_sha1, ie.text_size = self._add_text_to_weave(
 
362
                    ie.file_id, lines, heads, nostore_sha)
 
363
            except errors.ExistingContent:
 
364
                # Turns out that the file content was unchanged, and we were
 
365
                # only going to store a new node if it was changed. Carry over
 
366
                # the entry.
 
367
                ie.revision = parent_entry.revision
 
368
                ie.text_size = parent_entry.text_size
 
369
                ie.text_sha1 = parent_entry.text_sha1
 
370
                ie.executable = parent_entry.executable
 
371
                return self._get_delta(ie, basis_inv, path), False
 
372
        elif kind == 'directory':
 
373
            if not store:
 
374
                # all data is meta here, nothing specific to directory, so
 
375
                # carry over:
 
376
                ie.revision = parent_entry.revision
 
377
                return self._get_delta(ie, basis_inv, path), False
 
378
            lines = []
 
379
            self._add_text_to_weave(ie.file_id, lines, heads, None)
 
380
        elif kind == 'symlink':
 
381
            current_link_target = content_summary[3]
 
382
            if not store:
 
383
                # symlink target is not generic metadata, check if it has
 
384
                # changed.
 
385
                if current_link_target != parent_entry.symlink_target:
 
386
                    store = True
 
387
            if not store:
 
388
                # unchanged, carry over.
 
389
                ie.revision = parent_entry.revision
 
390
                ie.symlink_target = parent_entry.symlink_target
 
391
                return self._get_delta(ie, basis_inv, path), False
 
392
            ie.symlink_target = current_link_target
 
393
            lines = []
 
394
            self._add_text_to_weave(ie.file_id, lines, heads, None)
 
395
        elif kind == 'tree-reference':
 
396
            if not store:
 
397
                if content_summary[3] != parent_entry.reference_revision:
 
398
                    store = True
 
399
            if not store:
 
400
                # unchanged, carry over.
 
401
                ie.reference_revision = parent_entry.reference_revision
 
402
                ie.revision = parent_entry.revision
 
403
                return self._get_delta(ie, basis_inv, path), False
 
404
            ie.reference_revision = content_summary[3]
 
405
            lines = []
 
406
            self._add_text_to_weave(ie.file_id, lines, heads, None)
 
407
        else:
 
408
            raise NotImplementedError('unknown kind')
 
409
        ie.revision = self._new_revision_id
 
410
        return self._get_delta(ie, basis_inv, path), True
 
411
 
 
412
    def _add_text_to_weave(self, file_id, new_lines, parents, nostore_sha):
 
413
        versionedfile = self.repository.weave_store.get_weave_or_empty(
 
414
            file_id, self.repository.get_transaction())
 
415
        # Don't change this to add_lines - add_lines_with_ghosts is cheaper
 
416
        # than add_lines, and allows committing when a parent is ghosted for
 
417
        # some reason.
 
418
        # Note: as we read the content directly from the tree, we know its not
 
419
        # been turned into unicode or badly split - but a broken tree
 
420
        # implementation could give us bad output from readlines() so this is
 
421
        # not a guarantee of safety. What would be better is always checking
 
422
        # the content during test suite execution. RBC 20070912
 
423
        try:
 
424
            return versionedfile.add_lines_with_ghosts(
 
425
                self._new_revision_id, parents, new_lines,
 
426
                nostore_sha=nostore_sha, random_id=self.random_revid,
 
427
                check_content=False)[0:2]
 
428
        finally:
 
429
            versionedfile.clear_cache()
 
430
 
 
431
 
 
432
class RootCommitBuilder(CommitBuilder):
 
433
    """This commitbuilder actually records the root id"""
 
434
    
 
435
    # the root entry gets versioned properly by this builder.
 
436
    _versioned_root = True
 
437
 
 
438
    def _check_root(self, ie, parent_invs, tree):
 
439
        """Helper for record_entry_contents.
 
440
 
 
441
        :param ie: An entry being added.
 
442
        :param parent_invs: The inventories of the parent revisions of the
 
443
            commit.
 
444
        :param tree: The tree that is being committed.
 
445
        """
240
446
 
241
447
 
242
448
######################################################################
243
449
# Repositories
244
450
 
245
 
 
246
 
class Repository(_RelockDebugMixin, controldir.ControlComponent):
 
451
class Repository(object):
247
452
    """Repository holding history for one or more branches.
248
453
 
249
454
    The repository holds and retrieves historical information including
250
455
    revisions and file history.  It's normally accessed only by the Branch,
251
456
    which views a particular line of development through that history.
252
457
 
253
 
    See VersionedFileRepository in bzrlib.vf_repository for the
254
 
    base class for most Bazaar repositories.
 
458
    The Repository builds on top of Stores and a Transport, which respectively 
 
459
    describe the disk data format and the way of accessing the (possibly 
 
460
    remote) disk.
255
461
    """
256
462
 
257
 
    def abort_write_group(self, suppress_errors=False):
 
463
    # What class to use for a CommitBuilder. Often its simpler to change this
 
464
    # in a Repository class subclass rather than to override
 
465
    # get_commit_builder.
 
466
    _commit_builder_class = CommitBuilder
 
467
    # The search regex used by xml based repositories to determine what things
 
468
    # where changed in a single commit.
 
469
    _file_ids_altered_regex = lazy_regex.lazy_compile(
 
470
        r'file_id="(?P<file_id>[^"]+)"'
 
471
        r'.* revision="(?P<revision_id>[^"]+)"'
 
472
        )
 
473
 
 
474
    def abort_write_group(self):
258
475
        """Commit the contents accrued within the current write group.
259
476
 
260
 
        :param suppress_errors: if true, abort_write_group will catch and log
261
 
            unexpected errors that happen during the abort, rather than
262
 
            allowing them to propagate.  Defaults to False.
263
 
 
264
477
        :seealso: start_write_group.
265
478
        """
266
479
        if self._write_group is not self.get_transaction():
267
480
            # has an unlock or relock occured ?
268
 
            if suppress_errors:
269
 
                mutter(
270
 
                '(suppressed) mismatched lock context and write group. %r, %r',
271
 
                self._write_group, self.get_transaction())
272
 
                return
273
 
            raise errors.BzrError(
274
 
                'mismatched lock context and write group. %r, %r' %
275
 
                (self._write_group, self.get_transaction()))
276
 
        try:
277
 
            self._abort_write_group()
278
 
        except Exception, exc:
279
 
            self._write_group = None
280
 
            if not suppress_errors:
281
 
                raise
282
 
            mutter('abort_write_group failed')
283
 
            log_exception_quietly()
284
 
            note(gettext('bzr: ERROR (ignored): %s'), exc)
 
481
            raise errors.BzrError('mismatched lock context and write group.')
 
482
        self._abort_write_group()
285
483
        self._write_group = None
286
484
 
287
485
    def _abort_write_group(self):
288
486
        """Template method for per-repository write group cleanup.
289
 
 
290
 
        This is called during abort before the write group is considered to be
 
487
        
 
488
        This is called during abort before the write group is considered to be 
291
489
        finished and should cleanup any internal state accrued during the write
292
490
        group. There is no requirement that data handed to the repository be
293
491
        *not* made available - this is not a rollback - but neither should any
297
495
        attempted.
298
496
        """
299
497
 
300
 
    def add_fallback_repository(self, repository):
301
 
        """Add a repository to use for looking up data not held locally.
302
 
 
303
 
        :param repository: A repository.
304
 
        """
305
 
        raise NotImplementedError(self.add_fallback_repository)
306
 
 
307
 
    def _check_fallback_repository(self, repository):
308
 
        """Check that this repository can fallback to repository safely.
309
 
 
310
 
        Raise an error if not.
311
 
 
312
 
        :param repository: A repository to fallback to.
313
 
        """
314
 
        return InterRepository._assert_same_model(self, repository)
 
498
    def add_inventory(self, revision_id, inv, parents):
 
499
        """Add the inventory inv to the repository as revision_id.
 
500
        
 
501
        :param parents: The revision ids of the parents that revision_id
 
502
                        is known to have and are in the repository already.
 
503
 
 
504
        :returns: The validator(which is a sha1 digest, though what is sha'd is
 
505
            repository format specific) of the serialized inventory.
 
506
        """
 
507
        assert self.is_in_write_group()
 
508
        _mod_revision.check_not_reserved_id(revision_id)
 
509
        assert inv.revision_id is None or inv.revision_id == revision_id, \
 
510
            "Mismatch between inventory revision" \
 
511
            " id and insertion revid (%r, %r)" % (inv.revision_id, revision_id)
 
512
        assert inv.root is not None
 
513
        inv_lines = self._serialise_inventory_to_lines(inv)
 
514
        inv_vf = self.get_inventory_weave()
 
515
        return self._inventory_add_lines(inv_vf, revision_id, parents,
 
516
            inv_lines, check_content=False)
 
517
 
 
518
    def _inventory_add_lines(self, inv_vf, revision_id, parents, lines,
 
519
        check_content=True):
 
520
        """Store lines in inv_vf and return the sha1 of the inventory."""
 
521
        final_parents = []
 
522
        for parent in parents:
 
523
            if parent in inv_vf:
 
524
                final_parents.append(parent)
 
525
        return inv_vf.add_lines(revision_id, final_parents, lines,
 
526
            check_content=check_content)[0]
 
527
 
 
528
    def add_revision(self, revision_id, rev, inv=None, config=None):
 
529
        """Add rev to the revision store as revision_id.
 
530
 
 
531
        :param revision_id: the revision id to use.
 
532
        :param rev: The revision object.
 
533
        :param inv: The inventory for the revision. if None, it will be looked
 
534
                    up in the inventory storer
 
535
        :param config: If None no digital signature will be created.
 
536
                       If supplied its signature_needed method will be used
 
537
                       to determine if a signature should be made.
 
538
        """
 
539
        # TODO: jam 20070210 Shouldn't we check rev.revision_id and
 
540
        #       rev.parent_ids?
 
541
        _mod_revision.check_not_reserved_id(revision_id)
 
542
        if config is not None and config.signature_needed():
 
543
            if inv is None:
 
544
                inv = self.get_inventory(revision_id)
 
545
            plaintext = Testament(rev, inv).as_short_text()
 
546
            self.store_revision_signature(
 
547
                gpg.GPGStrategy(config), plaintext, revision_id)
 
548
        if not revision_id in self.get_inventory_weave():
 
549
            if inv is None:
 
550
                raise errors.WeaveRevisionNotPresent(revision_id,
 
551
                                                     self.get_inventory_weave())
 
552
            else:
 
553
                # yes, this is not suitable for adding with ghosts.
 
554
                self.add_inventory(revision_id, inv, rev.parent_ids)
 
555
        self._revision_store.add_revision(rev, self.get_transaction())
 
556
 
 
557
    def _add_revision_text(self, revision_id, text):
 
558
        revision = self._revision_store._serializer.read_revision_from_string(
 
559
            text)
 
560
        self._revision_store._add_revision(revision, StringIO(text),
 
561
                                           self.get_transaction())
315
562
 
316
563
    def all_revision_ids(self):
317
 
        """Returns a list of all the revision ids in the repository.
 
564
        """Returns a list of all the revision ids in the repository. 
318
565
 
319
 
        This is conceptually deprecated because code should generally work on
320
 
        the graph reachable from a particular revision, and ignore any other
321
 
        revisions that might be present.  There is no direct replacement
322
 
        method.
 
566
        This is deprecated because code should generally work on the graph
 
567
        reachable from a particular revision, and ignore any other revisions
 
568
        that might be present.  There is no direct replacement method.
323
569
        """
324
570
        if 'evil' in debug.debug_flags:
325
571
            mutter_callsite(2, "all_revision_ids is linear with history.")
326
572
        return self._all_revision_ids()
327
573
 
328
574
    def _all_revision_ids(self):
329
 
        """Returns a list of all the revision ids in the repository.
 
575
        """Returns a list of all the revision ids in the repository. 
330
576
 
331
 
        These are in as much topological order as the underlying store can
 
577
        These are in as much topological order as the underlying store can 
332
578
        present.
333
579
        """
334
580
        raise NotImplementedError(self._all_revision_ids)
341
587
        """
342
588
        self.control_files.break_lock()
343
589
 
 
590
    @needs_read_lock
 
591
    def _eliminate_revisions_not_present(self, revision_ids):
 
592
        """Check every revision id in revision_ids to see if we have it.
 
593
 
 
594
        Returns a set of the present revisions.
 
595
        """
 
596
        result = []
 
597
        for id in revision_ids:
 
598
            if self.has_revision(id):
 
599
               result.append(id)
 
600
        return result
 
601
 
344
602
    @staticmethod
345
 
    def create(controldir):
346
 
        """Construct the current default format repository in controldir."""
347
 
        return RepositoryFormat.get_default_format().initialize(controldir)
 
603
    def create(a_bzrdir):
 
604
        """Construct the current default format repository in a_bzrdir."""
 
605
        return RepositoryFormat.get_default_format().initialize(a_bzrdir)
348
606
 
349
 
    def __init__(self, _format, controldir, control_files):
 
607
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
350
608
        """instantiate a Repository.
351
609
 
352
610
        :param _format: The format of the repository on disk.
353
 
        :param controldir: The ControlDir of the repository.
354
 
        :param control_files: Control files to use for locking, etc.
 
611
        :param a_bzrdir: The BzrDir of the repository.
 
612
 
 
613
        In the future we will have a single api for all stores for
 
614
        getting file texts, inventories and revisions, then
 
615
        this construct will accept instances of those things.
355
616
        """
356
 
        # In the future we will have a single api for all stores for
357
 
        # getting file texts, inventories and revisions, then
358
 
        # this construct will accept instances of those things.
359
617
        super(Repository, self).__init__()
360
618
        self._format = _format
361
619
        # the following are part of the public API for Repository:
362
 
        self.bzrdir = controldir
 
620
        self.bzrdir = a_bzrdir
363
621
        self.control_files = control_files
 
622
        self._revision_store = _revision_store
 
623
        # backwards compatibility
 
624
        self.weave_store = text_store
364
625
        # for tests
 
626
        self._reconcile_does_inventory_gc = True
 
627
        self._reconcile_fixes_text_parents = False
 
628
        self._reconcile_backsup_inventory = True
 
629
        # not right yet - should be more semantically clear ? 
 
630
        # 
 
631
        self.control_store = control_store
 
632
        self.control_weaves = control_store
 
633
        # TODO: make sure to construct the right store classes, etc, depending
 
634
        # on whether escaping is required.
 
635
        self._warn_if_deprecated()
365
636
        self._write_group = None
366
 
        # Additional places to query for data.
367
 
        self._fallback_repositories = []
368
 
 
369
 
    @property
370
 
    def user_transport(self):
371
 
        return self.bzrdir.user_transport
372
 
 
373
 
    @property
374
 
    def control_transport(self):
375
 
        return self._transport
 
637
        self.base = control_files._transport.base
376
638
 
377
639
    def __repr__(self):
378
 
        if self._fallback_repositories:
379
 
            return '%s(%r, fallback_repositories=%r)' % (
380
 
                self.__class__.__name__,
381
 
                self.base,
382
 
                self._fallback_repositories)
383
 
        else:
384
 
            return '%s(%r)' % (self.__class__.__name__,
385
 
                               self.base)
386
 
 
387
 
    def _has_same_fallbacks(self, other_repo):
388
 
        """Returns true if the repositories have the same fallbacks."""
389
 
        my_fb = self._fallback_repositories
390
 
        other_fb = other_repo._fallback_repositories
391
 
        if len(my_fb) != len(other_fb):
392
 
            return False
393
 
        for f, g in zip(my_fb, other_fb):
394
 
            if not f.has_same_location(g):
395
 
                return False
396
 
        return True
 
640
        return '%s(%r)' % (self.__class__.__name__,
 
641
                           self.base)
397
642
 
398
643
    def has_same_location(self, other):
399
644
        """Returns a boolean indicating if this repository is at the same
404
649
        """
405
650
        if self.__class__ is not other.__class__:
406
651
            return False
407
 
        return (self.control_url == other.control_url)
 
652
        return (self.control_files._transport.base ==
 
653
                other.control_files._transport.base)
408
654
 
409
655
    def is_in_write_group(self):
410
656
        """Return True if there is an open write group.
426
672
        This causes caching within the repository obejct to start accumlating
427
673
        data during reads, and allows a 'write_group' to be obtained. Write
428
674
        groups must be used for actual data insertion.
429
 
 
430
 
        A token should be passed in if you know that you have locked the object
431
 
        some other way, and need to synchronise this object's state with that
432
 
        fact.
433
 
 
434
 
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
435
 
 
 
675
        
436
676
        :param token: if this is already locked, then lock_write will fail
437
677
            unless the token matches the existing lock.
438
678
        :returns: a token if this instance supports tokens, otherwise None.
441
681
        :raises MismatchedToken: if the specified token doesn't match the token
442
682
            of the existing lock.
443
683
        :seealso: start_write_group.
444
 
        :return: A RepositoryWriteLockResult.
 
684
 
 
685
        A token should be passed in if you know that you have locked the object
 
686
        some other way, and need to synchronise this object's state with that
 
687
        fact.
 
688
 
 
689
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
445
690
        """
446
 
        locked = self.is_locked()
447
 
        token = self.control_files.lock_write(token=token)
448
 
        if not locked:
449
 
            self._warn_if_deprecated()
450
 
            self._note_lock('w')
451
 
            for repo in self._fallback_repositories:
452
 
                # Writes don't affect fallback repos
453
 
                repo.lock_read()
454
 
            self._refresh_data()
455
 
        return RepositoryWriteLockResult(self.unlock, token)
 
691
        result = self.control_files.lock_write(token=token)
 
692
        self._refresh_data()
 
693
        return result
456
694
 
457
695
    def lock_read(self):
458
 
        """Lock the repository for read operations.
459
 
 
460
 
        :return: An object with an unlock method which will release the lock
461
 
            obtained.
462
 
        """
463
 
        locked = self.is_locked()
464
696
        self.control_files.lock_read()
465
 
        if not locked:
466
 
            self._warn_if_deprecated()
467
 
            self._note_lock('r')
468
 
            for repo in self._fallback_repositories:
469
 
                repo.lock_read()
470
 
            self._refresh_data()
471
 
        return LogicalLockResult(self.unlock)
 
697
        self._refresh_data()
472
698
 
473
699
    def get_physical_lock_status(self):
474
700
        return self.control_files.get_physical_lock_status()
476
702
    def leave_lock_in_place(self):
477
703
        """Tell this repository not to release the physical lock when this
478
704
        object is unlocked.
479
 
 
 
705
        
480
706
        If lock_write doesn't return a token, then this method is not supported.
481
707
        """
482
708
        self.control_files.leave_in_place()
510
736
        if revid and committers:
511
737
            result['committers'] = 0
512
738
        if revid and revid != _mod_revision.NULL_REVISION:
513
 
            graph = self.get_graph()
514
739
            if committers:
515
740
                all_committers = set()
516
 
            revisions = [r for (r, p) in graph.iter_ancestry([revid])
517
 
                        if r != _mod_revision.NULL_REVISION]
518
 
            last_revision = None
 
741
            revisions = self.get_ancestry(revid)
 
742
            # pop the leading None
 
743
            revisions.pop(0)
 
744
            first_revision = None
519
745
            if not committers:
520
746
                # ignore the revisions in the middle - just grab first and last
521
747
                revisions = revisions[0], revisions[-1]
522
748
            for revision in self.get_revisions(revisions):
523
 
                if not last_revision:
524
 
                    last_revision = revision
 
749
                if not first_revision:
 
750
                    first_revision = revision
525
751
                if committers:
526
752
                    all_committers.add(revision.committer)
527
 
            first_revision = revision
 
753
            last_revision = revision
528
754
            if committers:
529
755
                result['committers'] = len(all_committers)
530
756
            result['firstrev'] = (first_revision.timestamp,
531
757
                first_revision.timezone)
532
758
            result['latestrev'] = (last_revision.timestamp,
533
759
                last_revision.timezone)
 
760
 
 
761
        # now gather global repository information
 
762
        if self.bzrdir.root_transport.listable():
 
763
            c, t = self._revision_store.total_size(self.get_transaction())
 
764
            result['revisions'] = c
 
765
            result['size'] = t
534
766
        return result
535
767
 
536
768
    def find_branches(self, using=False):
541
773
        :param using: If True, list only branches using this repository.
542
774
        """
543
775
        if using and not self.is_shared():
544
 
            return self.bzrdir.list_branches()
 
776
            try:
 
777
                return [self.bzrdir.open_branch()]
 
778
            except errors.NotBranchError:
 
779
                return []
545
780
        class Evaluator(object):
546
781
 
547
782
            def __init__(self):
548
783
                self.first_call = True
549
784
 
550
 
            def __call__(self, controldir):
551
 
                # On the first call, the parameter is always the controldir
 
785
            def __call__(self, bzrdir):
 
786
                # On the first call, the parameter is always the bzrdir
552
787
                # containing the current repo.
553
788
                if not self.first_call:
554
789
                    try:
555
 
                        repository = controldir.open_repository()
 
790
                        repository = bzrdir.open_repository()
556
791
                    except errors.NoRepositoryPresent:
557
792
                        pass
558
793
                    else:
559
 
                        return False, ([], repository)
 
794
                        return False, (None, repository)
560
795
                self.first_call = False
561
 
                value = (controldir.list_branches(), None)
 
796
                try:
 
797
                    value = (bzrdir.open_branch(), None)
 
798
                except errors.NotBranchError:
 
799
                    value = (None, None)
562
800
                return True, value
563
801
 
564
 
        ret = []
565
 
        for branches, repository in controldir.ControlDir.find_bzrdirs(
566
 
                self.user_transport, evaluate=Evaluator()):
567
 
            if branches is not None:
568
 
                ret.extend(branches)
 
802
        branches = []
 
803
        for branch, repository in bzrdir.BzrDir.find_bzrdirs(
 
804
                self.bzrdir.root_transport, evaluate=Evaluator()):
 
805
            if branch is not None:
 
806
                branches.append(branch)
569
807
            if not using and repository is not None:
570
 
                ret.extend(repository.find_branches())
571
 
        return ret
 
808
                branches.extend(repository.find_branches())
 
809
        return branches
 
810
 
 
811
    def get_data_stream(self, revision_ids):
 
812
        raise NotImplementedError(self.get_data_stream)
 
813
 
 
814
    def get_data_stream_for_search(self, search_result):
 
815
        """Get a data stream that can be inserted to a repository.
 
816
 
 
817
        :param search_result: A bzrlib.graph.SearchResult selecting the
 
818
            revisions to get.
 
819
        :return: A data stream that can be inserted into a repository using
 
820
            insert_data_stream.
 
821
        """
 
822
        raise NotImplementedError(self.get_data_stream_for_search)
 
823
 
 
824
    def insert_data_stream(self, stream):
 
825
        """XXX What does this really do? 
 
826
        
 
827
        Is it a substitute for fetch? 
 
828
        Should it manage its own write group ?
 
829
        """
 
830
        for item_key, bytes in stream:
 
831
            if item_key[0] == 'file':
 
832
                (file_id,) = item_key[1:]
 
833
                knit = self.weave_store.get_weave_or_empty(
 
834
                    file_id, self.get_transaction())
 
835
            elif item_key == ('inventory',):
 
836
                knit = self.get_inventory_weave()
 
837
            elif item_key == ('revisions',):
 
838
                knit = self._revision_store.get_revision_file(
 
839
                    self.get_transaction())
 
840
            elif item_key == ('signatures',):
 
841
                knit = self._revision_store.get_signature_file(
 
842
                    self.get_transaction())
 
843
            else:
 
844
                raise errors.RepositoryDataStreamError(
 
845
                    "Unrecognised data stream key '%s'" % (item_key,))
 
846
            decoded_list = bencode.bdecode(bytes)
 
847
            format = decoded_list.pop(0)
 
848
            data_list = []
 
849
            knit_bytes = ''
 
850
            for version, options, parents, some_bytes in decoded_list:
 
851
                data_list.append((version, options, len(some_bytes), parents))
 
852
                knit_bytes += some_bytes
 
853
            buffer = StringIO(knit_bytes)
 
854
            def reader_func(count):
 
855
                if count is None:
 
856
                    return buffer.read()
 
857
                else:
 
858
                    return buffer.read(count)
 
859
            knit.insert_data_stream(
 
860
                (format, data_list, reader_func))
572
861
 
573
862
    @needs_read_lock
574
 
    def search_missing_revision_ids(self, other,
575
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
576
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
577
 
            limit=None):
 
863
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
578
864
        """Return the revision ids that other has that this does not.
579
 
 
 
865
        
580
866
        These are returned in topological order.
581
867
 
582
868
        revision_id: only return revision ids included by revision_id.
583
869
        """
584
 
        if symbol_versioning.deprecated_passed(revision_id):
585
 
            symbol_versioning.warn(
586
 
                'search_missing_revision_ids(revision_id=...) was '
587
 
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
588
 
                DeprecationWarning, stacklevel=3)
589
 
            if revision_ids is not None:
590
 
                raise AssertionError(
591
 
                    'revision_ids is mutually exclusive with revision_id')
592
 
            if revision_id is not None:
593
 
                revision_ids = [revision_id]
594
870
        return InterRepository.get(other, self).search_missing_revision_ids(
595
 
            find_ghosts=find_ghosts, revision_ids=revision_ids,
596
 
            if_present_ids=if_present_ids, limit=limit)
 
871
            revision_id, find_ghosts)
 
872
 
 
873
    @deprecated_method(symbol_versioning.one_two)
 
874
    @needs_read_lock
 
875
    def missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
876
        """Return the revision ids that other has that this does not.
 
877
        
 
878
        These are returned in topological order.
 
879
 
 
880
        revision_id: only return revision ids included by revision_id.
 
881
        """
 
882
        keys =  self.search_missing_revision_ids(
 
883
            other, revision_id, find_ghosts).get_keys()
 
884
        other.lock_read()
 
885
        try:
 
886
            parents = other.get_graph().get_parent_map(keys)
 
887
        finally:
 
888
            other.unlock()
 
889
        return tsort.topo_sort(parents)
597
890
 
598
891
    @staticmethod
599
892
    def open(base):
602
895
        For instance, if the repository is at URL/.bzr/repository,
603
896
        Repository.open(URL) -> a Repository instance.
604
897
        """
605
 
        control = controldir.ControlDir.open(base)
 
898
        control = bzrdir.BzrDir.open(base)
606
899
        return control.open_repository()
607
900
 
608
901
    def copy_content_into(self, destination, revision_id=None):
609
902
        """Make a complete copy of the content in self into destination.
610
 
 
611
 
        This is a destructive operation! Do not use it on existing
 
903
        
 
904
        This is a destructive operation! Do not use it on existing 
612
905
        repositories.
613
906
        """
614
907
        return InterRepository.get(self, destination).copy_content(revision_id)
617
910
        """Commit the contents accrued within the current write group.
618
911
 
619
912
        :seealso: start_write_group.
620
 
        
621
 
        :return: it may return an opaque hint that can be passed to 'pack'.
622
913
        """
623
914
        if self._write_group is not self.get_transaction():
624
915
            # has an unlock or relock occured ?
625
916
            raise errors.BzrError('mismatched lock context %r and '
626
917
                'write group %r.' %
627
918
                (self.get_transaction(), self._write_group))
628
 
        result = self._commit_write_group()
 
919
        self._commit_write_group()
629
920
        self._write_group = None
630
 
        return result
631
921
 
632
922
    def _commit_write_group(self):
633
923
        """Template method for per-repository write group cleanup.
634
 
 
635
 
        This is called before the write group is considered to be
 
924
        
 
925
        This is called before the write group is considered to be 
636
926
        finished and should ensure that all data handed to the repository
637
 
        for writing during the write group is safely committed (to the
 
927
        for writing during the write group is safely committed (to the 
638
928
        extent possible considering file system caching etc).
639
929
        """
640
930
 
641
 
    def suspend_write_group(self):
642
 
        raise errors.UnsuspendableWriteGroup(self)
643
 
 
644
 
    def refresh_data(self):
645
 
        """Re-read any data needed to synchronise with disk.
646
 
 
647
 
        This method is intended to be called after another repository instance
648
 
        (such as one used by a smart server) has inserted data into the
649
 
        repository. On all repositories this will work outside of write groups.
650
 
        Some repository formats (pack and newer for bzrlib native formats)
651
 
        support refresh_data inside write groups. If called inside a write
652
 
        group on a repository that does not support refreshing in a write group
653
 
        IsInWriteGroupError will be raised.
654
 
        """
655
 
        self._refresh_data()
656
 
 
657
 
    def resume_write_group(self, tokens):
658
 
        if not self.is_write_locked():
659
 
            raise errors.NotWriteLocked(self)
660
 
        if self._write_group:
661
 
            raise errors.BzrError('already in a write group')
662
 
        self._resume_write_group(tokens)
663
 
        # so we can detect unlock/relock - the write group is now entered.
664
 
        self._write_group = self.get_transaction()
665
 
 
666
 
    def _resume_write_group(self, tokens):
667
 
        raise errors.UnsuspendableWriteGroup(self)
668
 
 
669
 
    def fetch(self, source, revision_id=None, find_ghosts=False,
670
 
            fetch_spec=None):
 
931
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False):
671
932
        """Fetch the content required to construct revision_id from source.
672
933
 
673
 
        If revision_id is None and fetch_spec is None, then all content is
674
 
        copied.
675
 
 
676
 
        fetch() may not be used when the repository is in a write group -
677
 
        either finish the current write group before using fetch, or use
678
 
        fetch before starting the write group.
679
 
 
 
934
        If revision_id is None all content is copied.
680
935
        :param find_ghosts: Find and copy revisions in the source that are
681
936
            ghosts in the target (and not reachable directly by walking out to
682
937
            the first-present revision in target from revision_id).
683
 
        :param revision_id: If specified, all the content needed for this
684
 
            revision ID will be copied to the target.  Fetch will determine for
685
 
            itself which content needs to be copied.
686
 
        :param fetch_spec: If specified, a SearchResult or
687
 
            PendingAncestryResult that describes which revisions to copy.  This
688
 
            allows copying multiple heads at once.  Mutually exclusive with
689
 
            revision_id.
690
938
        """
691
 
        if fetch_spec is not None and revision_id is not None:
692
 
            raise AssertionError(
693
 
                "fetch_spec and revision_id are mutually exclusive.")
694
 
        if self.is_in_write_group():
695
 
            raise errors.InternalBzrError(
696
 
                "May not fetch while in a write group.")
697
939
        # fast path same-url fetch operations
698
 
        # TODO: lift out to somewhere common with RemoteRepository
699
 
        # <https://bugs.launchpad.net/bzr/+bug/401646>
700
 
        if (self.has_same_location(source)
701
 
            and fetch_spec is None
702
 
            and self._has_same_fallbacks(source)):
 
940
        if self.has_same_location(source):
703
941
            # check that last_revision is in 'from' and then return a
704
942
            # no-operation.
705
943
            if (revision_id is not None and
707
945
                self.get_revision(revision_id)
708
946
            return 0, []
709
947
        inter = InterRepository.get(source, self)
710
 
        return inter.fetch(revision_id=revision_id,
711
 
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
 
948
        try:
 
949
            return inter.fetch(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts)
 
950
        except NotImplementedError:
 
951
            raise errors.IncompatibleRepositories(source, self)
712
952
 
713
953
    def create_bundle(self, target, base, fileobj, format=None):
714
954
        return serializer.write_bundle(self, target, base, fileobj, format)
715
955
 
716
956
    def get_commit_builder(self, branch, parents, config, timestamp=None,
717
957
                           timezone=None, committer=None, revprops=None,
718
 
                           revision_id=None, lossy=False):
 
958
                           revision_id=None):
719
959
        """Obtain a CommitBuilder for this repository.
720
 
 
 
960
        
721
961
        :param branch: Branch to commit to.
722
962
        :param parents: Revision ids of the parents of the new revision.
723
963
        :param config: Configuration to use.
726
966
        :param committer: Optional committer to set for commit.
727
967
        :param revprops: Optional dictionary of revision properties.
728
968
        :param revision_id: Optional revision id.
729
 
        :param lossy: Whether to discard data that can not be natively
730
 
            represented, when pushing to a foreign VCS
731
969
        """
732
 
        raise NotImplementedError(self.get_commit_builder)
 
970
        result = self._commit_builder_class(self, parents, config,
 
971
            timestamp, timezone, committer, revprops, revision_id)
 
972
        self.start_write_group()
 
973
        return result
733
974
 
734
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
735
975
    def unlock(self):
736
976
        if (self.control_files._lock_count == 1 and
737
977
            self.control_files._lock_mode == 'w'):
741
981
                raise errors.BzrError(
742
982
                    'Must end write groups before releasing write locks.')
743
983
        self.control_files.unlock()
744
 
        if self.control_files._lock_count == 0:
745
 
            for repo in self._fallback_repositories:
746
 
                repo.unlock()
747
984
 
748
985
    @needs_read_lock
749
 
    def clone(self, controldir, revision_id=None):
750
 
        """Clone this repository into controldir using the current format.
 
986
    def clone(self, a_bzrdir, revision_id=None):
 
987
        """Clone this repository into a_bzrdir using the current format.
751
988
 
752
989
        Currently no check is made that the format of this repository and
753
990
        the bzrdir format are compatible. FIXME RBC 20060201.
756
993
        """
757
994
        # TODO: deprecate after 0.16; cloning this with all its settings is
758
995
        # probably not very useful -- mbp 20070423
759
 
        dest_repo = self._create_sprouting_repo(
760
 
            controldir, shared=self.is_shared())
 
996
        dest_repo = self._create_sprouting_repo(a_bzrdir, shared=self.is_shared())
761
997
        self.copy_content_into(dest_repo, revision_id)
762
998
        return dest_repo
763
999
 
785
1021
 
786
1022
    def _start_write_group(self):
787
1023
        """Template method for per-repository write group startup.
788
 
 
789
 
        This is called before the write group is considered to be
 
1024
        
 
1025
        This is called before the write group is considered to be 
790
1026
        entered.
791
1027
        """
792
1028
 
818
1054
        """True if this repository has a copy of the revision."""
819
1055
        return revision_id in self.has_revisions((revision_id,))
820
1056
 
821
 
    @needs_read_lock
822
1057
    def has_revisions(self, revision_ids):
823
1058
        """Probe to find out the presence of multiple revisions.
824
1059
 
827
1062
        """
828
1063
        raise NotImplementedError(self.has_revisions)
829
1064
 
 
1065
        return self._revision_store.has_revision_id(revision_id,
 
1066
                                                    self.get_transaction())
 
1067
 
830
1068
    @needs_read_lock
831
1069
    def get_revision(self, revision_id):
832
1070
        """Return the Revision object for a named revision."""
833
1071
        return self.get_revisions([revision_id])[0]
834
1072
 
 
1073
    @needs_read_lock
835
1074
    def get_revision_reconcile(self, revision_id):
836
1075
        """'reconcile' helper routine that allows access to a revision always.
837
 
 
 
1076
        
838
1077
        This variant of get_revision does not cross check the weave graph
839
1078
        against the revision one as get_revision does: but it should only
840
1079
        be used by reconcile, or reconcile-alike commands that are correcting
841
1080
        or testing the revision graph.
842
1081
        """
843
 
        raise NotImplementedError(self.get_revision_reconcile)
 
1082
        return self._get_revisions([revision_id])[0]
844
1083
 
 
1084
    @needs_read_lock
845
1085
    def get_revisions(self, revision_ids):
846
 
        """Get many revisions at once.
847
 
        
848
 
        Repositories that need to check data on every revision read should 
849
 
        subclass this method.
850
 
        """
851
 
        raise NotImplementedError(self.get_revisions)
852
 
 
853
 
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
 
1086
        """Get many revisions at once."""
 
1087
        return self._get_revisions(revision_ids)
 
1088
 
 
1089
    @needs_read_lock
 
1090
    def _get_revisions(self, revision_ids):
 
1091
        """Core work logic to get many revisions without sanity checks."""
 
1092
        for rev_id in revision_ids:
 
1093
            if not rev_id or not isinstance(rev_id, basestring):
 
1094
                raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
 
1095
        revs = self._revision_store.get_revisions(revision_ids,
 
1096
                                                  self.get_transaction())
 
1097
        for rev in revs:
 
1098
            assert not isinstance(rev.revision_id, unicode)
 
1099
            for parent_id in rev.parent_ids:
 
1100
                assert not isinstance(parent_id, unicode)
 
1101
        return revs
 
1102
 
 
1103
    @needs_read_lock
 
1104
    def get_revision_xml(self, revision_id):
 
1105
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
1106
        #       would have already do it.
 
1107
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
1108
        rev = self.get_revision(revision_id)
 
1109
        rev_tmp = StringIO()
 
1110
        # the current serializer..
 
1111
        self._revision_store._serializer.write_revision(rev, rev_tmp)
 
1112
        rev_tmp.seek(0)
 
1113
        return rev_tmp.getvalue()
 
1114
 
 
1115
    @needs_read_lock
 
1116
    def get_deltas_for_revisions(self, revisions):
854
1117
        """Produce a generator of revision deltas.
855
 
 
 
1118
        
856
1119
        Note that the input is a sequence of REVISIONS, not revision_ids.
857
1120
        Trees will be held in memory until the generator exits.
858
1121
        Each delta is relative to the revision's lefthand predecessor.
859
 
 
860
 
        :param specific_fileids: if not None, the result is filtered
861
 
          so that only those file-ids, their parents and their
862
 
          children are included.
863
1122
        """
864
 
        # Get the revision-ids of interest
865
1123
        required_trees = set()
866
1124
        for revision in revisions:
867
1125
            required_trees.add(revision.revision_id)
868
1126
            required_trees.update(revision.parent_ids[:1])
869
 
 
870
 
        # Get the matching filtered trees. Note that it's more
871
 
        # efficient to pass filtered trees to changes_from() rather
872
 
        # than doing the filtering afterwards. changes_from() could
873
 
        # arguably do the filtering itself but it's path-based, not
874
 
        # file-id based, so filtering before or afterwards is
875
 
        # currently easier.
876
 
        if specific_fileids is None:
877
 
            trees = dict((t.get_revision_id(), t) for
878
 
                t in self.revision_trees(required_trees))
879
 
        else:
880
 
            trees = dict((t.get_revision_id(), t) for
881
 
                t in self._filtered_revision_trees(required_trees,
882
 
                specific_fileids))
883
 
 
884
 
        # Calculate the deltas
 
1127
        trees = dict((t.get_revision_id(), t) for 
 
1128
                     t in self.revision_trees(required_trees))
885
1129
        for revision in revisions:
886
1130
            if not revision.parent_ids:
887
 
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
1131
                old_tree = self.revision_tree(None)
888
1132
            else:
889
1133
                old_tree = trees[revision.parent_ids[0]]
890
1134
            yield trees[revision.revision_id].changes_from(old_tree)
891
1135
 
892
1136
    @needs_read_lock
893
 
    def get_revision_delta(self, revision_id, specific_fileids=None):
 
1137
    def get_revision_delta(self, revision_id):
894
1138
        """Return the delta for one revision.
895
1139
 
896
1140
        The delta is relative to the left-hand predecessor of the
897
1141
        revision.
898
 
 
899
 
        :param specific_fileids: if not None, the result is filtered
900
 
          so that only those file-ids, their parents and their
901
 
          children are included.
902
1142
        """
903
1143
        r = self.get_revision(revision_id)
904
 
        return list(self.get_deltas_for_revisions([r],
905
 
            specific_fileids=specific_fileids))[0]
 
1144
        return list(self.get_deltas_for_revisions([r]))[0]
906
1145
 
907
1146
    @needs_write_lock
908
1147
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
909
1148
        signature = gpg_strategy.sign(plaintext)
910
1149
        self.add_signature_text(revision_id, signature)
911
1150
 
 
1151
    @needs_write_lock
912
1152
    def add_signature_text(self, revision_id, signature):
913
 
        """Store a signature text for a revision.
914
 
 
915
 
        :param revision_id: Revision id of the revision
916
 
        :param signature: Signature text.
917
 
        """
918
 
        raise NotImplementedError(self.add_signature_text)
919
 
 
920
 
    def _find_parent_ids_of_revisions(self, revision_ids):
921
 
        """Find all parent ids that are mentioned in the revision graph.
922
 
 
923
 
        :return: set of revisions that are parents of revision_ids which are
924
 
            not part of revision_ids themselves
925
 
        """
926
 
        parent_map = self.get_parent_map(revision_ids)
927
 
        parent_ids = set()
928
 
        map(parent_ids.update, parent_map.itervalues())
929
 
        parent_ids.difference_update(revision_ids)
930
 
        parent_ids.discard(_mod_revision.NULL_REVISION)
931
 
        return parent_ids
 
1153
        self._revision_store.add_revision_signature_text(revision_id,
 
1154
                                                         signature,
 
1155
                                                         self.get_transaction())
 
1156
 
 
1157
    def find_text_key_references(self):
 
1158
        """Find the text key references within the repository.
 
1159
 
 
1160
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
 
1161
        revision_ids. Each altered file-ids has the exact revision_ids that
 
1162
        altered it listed explicitly.
 
1163
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
 
1164
            to whether they were referred to by the inventory of the
 
1165
            revision_id that they contain. The inventory texts from all present
 
1166
            revision ids are assessed to generate this report.
 
1167
        """
 
1168
        revision_ids = self.all_revision_ids()
 
1169
        w = self.get_inventory_weave()
 
1170
        pb = ui.ui_factory.nested_progress_bar()
 
1171
        try:
 
1172
            return self._find_text_key_references_from_xml_inventory_lines(
 
1173
                w.iter_lines_added_or_present_in_versions(revision_ids, pb=pb))
 
1174
        finally:
 
1175
            pb.finished()
 
1176
 
 
1177
    def _find_text_key_references_from_xml_inventory_lines(self,
 
1178
        line_iterator):
 
1179
        """Core routine for extracting references to texts from inventories.
 
1180
 
 
1181
        This performs the translation of xml lines to revision ids.
 
1182
 
 
1183
        :param line_iterator: An iterator of lines, origin_version_id
 
1184
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
 
1185
            to whether they were referred to by the inventory of the
 
1186
            revision_id that they contain. Note that if that revision_id was
 
1187
            not part of the line_iterator's output then False will be given -
 
1188
            even though it may actually refer to that key.
 
1189
        """
 
1190
        if not self._serializer.support_altered_by_hack:
 
1191
            raise AssertionError(
 
1192
                "_find_text_key_references_from_xml_inventory_lines only "
 
1193
                "supported for branches which store inventory as unnested xml"
 
1194
                ", not on %r" % self)
 
1195
        result = {}
 
1196
 
 
1197
        # this code needs to read every new line in every inventory for the
 
1198
        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
 
1199
        # not present in one of those inventories is unnecessary but not 
 
1200
        # harmful because we are filtering by the revision id marker in the
 
1201
        # inventory lines : we only select file ids altered in one of those  
 
1202
        # revisions. We don't need to see all lines in the inventory because
 
1203
        # only those added in an inventory in rev X can contain a revision=X
 
1204
        # line.
 
1205
        unescape_revid_cache = {}
 
1206
        unescape_fileid_cache = {}
 
1207
 
 
1208
        # jam 20061218 In a big fetch, this handles hundreds of thousands
 
1209
        # of lines, so it has had a lot of inlining and optimizing done.
 
1210
        # Sorry that it is a little bit messy.
 
1211
        # Move several functions to be local variables, since this is a long
 
1212
        # running loop.
 
1213
        search = self._file_ids_altered_regex.search
 
1214
        unescape = _unescape_xml
 
1215
        setdefault = result.setdefault
 
1216
        for line, version_id in line_iterator:
 
1217
            match = search(line)
 
1218
            if match is None:
 
1219
                continue
 
1220
            # One call to match.group() returning multiple items is quite a
 
1221
            # bit faster than 2 calls to match.group() each returning 1
 
1222
            file_id, revision_id = match.group('file_id', 'revision_id')
 
1223
 
 
1224
            # Inlining the cache lookups helps a lot when you make 170,000
 
1225
            # lines and 350k ids, versus 8.4 unique ids.
 
1226
            # Using a cache helps in 2 ways:
 
1227
            #   1) Avoids unnecessary decoding calls
 
1228
            #   2) Re-uses cached strings, which helps in future set and
 
1229
            #      equality checks.
 
1230
            # (2) is enough that removing encoding entirely along with
 
1231
            # the cache (so we are using plain strings) results in no
 
1232
            # performance improvement.
 
1233
            try:
 
1234
                revision_id = unescape_revid_cache[revision_id]
 
1235
            except KeyError:
 
1236
                unescaped = unescape(revision_id)
 
1237
                unescape_revid_cache[revision_id] = unescaped
 
1238
                revision_id = unescaped
 
1239
 
 
1240
            # Note that unconditionally unescaping means that we deserialise
 
1241
            # every fileid, which for general 'pull' is not great, but we don't
 
1242
            # really want to have some many fulltexts that this matters anyway.
 
1243
            # RBC 20071114.
 
1244
            try:
 
1245
                file_id = unescape_fileid_cache[file_id]
 
1246
            except KeyError:
 
1247
                unescaped = unescape(file_id)
 
1248
                unescape_fileid_cache[file_id] = unescaped
 
1249
                file_id = unescaped
 
1250
 
 
1251
            key = (file_id, revision_id)
 
1252
            setdefault(key, False)
 
1253
            if revision_id == version_id:
 
1254
                result[key] = True
 
1255
        return result
 
1256
 
 
1257
    def _find_file_ids_from_xml_inventory_lines(self, line_iterator,
 
1258
        revision_ids):
 
1259
        """Helper routine for fileids_altered_by_revision_ids.
 
1260
 
 
1261
        This performs the translation of xml lines to revision ids.
 
1262
 
 
1263
        :param line_iterator: An iterator of lines, origin_version_id
 
1264
        :param revision_ids: The revision ids to filter for. This should be a
 
1265
            set or other type which supports efficient __contains__ lookups, as
 
1266
            the revision id from each parsed line will be looked up in the
 
1267
            revision_ids filter.
 
1268
        :return: a dictionary mapping altered file-ids to an iterable of
 
1269
        revision_ids. Each altered file-ids has the exact revision_ids that
 
1270
        altered it listed explicitly.
 
1271
        """
 
1272
        result = {}
 
1273
        setdefault = result.setdefault
 
1274
        for file_id, revision_id in \
 
1275
            self._find_text_key_references_from_xml_inventory_lines(
 
1276
                line_iterator).iterkeys():
 
1277
            # once data is all ensured-consistent; then this is
 
1278
            # if revision_id == version_id
 
1279
            if revision_id in revision_ids:
 
1280
                setdefault(file_id, set()).add(revision_id)
 
1281
        return result
 
1282
 
 
1283
    def fileids_altered_by_revision_ids(self, revision_ids):
 
1284
        """Find the file ids and versions affected by revisions.
 
1285
 
 
1286
        :param revisions: an iterable containing revision ids.
 
1287
        :return: a dictionary mapping altered file-ids to an iterable of
 
1288
        revision_ids. Each altered file-ids has the exact revision_ids that
 
1289
        altered it listed explicitly.
 
1290
        """
 
1291
        selected_revision_ids = set(revision_ids)
 
1292
        w = self.get_inventory_weave()
 
1293
        pb = ui.ui_factory.nested_progress_bar()
 
1294
        try:
 
1295
            return self._find_file_ids_from_xml_inventory_lines(
 
1296
                w.iter_lines_added_or_present_in_versions(
 
1297
                    selected_revision_ids, pb=pb),
 
1298
                selected_revision_ids)
 
1299
        finally:
 
1300
            pb.finished()
932
1301
 
933
1302
    def iter_files_bytes(self, desired_files):
934
1303
        """Iterate through file versions.
941
1310
        uniquely identify the file version in the caller's context.  (Examples:
942
1311
        an index number or a TreeTransform trans_id.)
943
1312
 
 
1313
        bytes_iterator is an iterable of bytestrings for the file.  The
 
1314
        kind of iterable and length of the bytestrings are unspecified, but for
 
1315
        this implementation, it is a list of lines produced by
 
1316
        VersionedFile.get_lines().
 
1317
 
944
1318
        :param desired_files: a list of (file_id, revision_id, identifier)
945
1319
            triples
946
1320
        """
947
 
        raise NotImplementedError(self.iter_files_bytes)
948
 
 
949
 
    def get_rev_id_for_revno(self, revno, known_pair):
950
 
        """Return the revision id of a revno, given a later (revno, revid)
951
 
        pair in the same history.
952
 
 
953
 
        :return: if found (True, revid).  If the available history ran out
954
 
            before reaching the revno, then this returns
955
 
            (False, (closest_revno, closest_revid)).
956
 
        """
957
 
        known_revno, known_revid = known_pair
958
 
        partial_history = [known_revid]
959
 
        distance_from_known = known_revno - revno
960
 
        if distance_from_known < 0:
961
 
            raise ValueError(
962
 
                'requested revno (%d) is later than given known revno (%d)'
963
 
                % (revno, known_revno))
964
 
        try:
965
 
            _iter_for_revno(
966
 
                self, partial_history, stop_index=distance_from_known)
967
 
        except errors.RevisionNotPresent, err:
968
 
            if err.revision_id == known_revid:
969
 
                # The start revision (known_revid) wasn't found.
970
 
                raise
971
 
            # This is a stacked repository with no fallbacks, or a there's a
972
 
            # left-hand ghost.  Either way, even though the revision named in
973
 
            # the error isn't in this repo, we know it's the next step in this
974
 
            # left-hand history.
975
 
            partial_history.append(err.revision_id)
976
 
        if len(partial_history) <= distance_from_known:
977
 
            # Didn't find enough history to get a revid for the revno.
978
 
            earliest_revno = known_revno - len(partial_history) + 1
979
 
            return (False, (earliest_revno, partial_history[-1]))
980
 
        if len(partial_history) - 1 > distance_from_known:
981
 
            raise AssertionError('_iter_for_revno returned too much history')
982
 
        return (True, partial_history[-1])
983
 
 
984
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
 
1321
        transaction = self.get_transaction()
 
1322
        for file_id, revision_id, callable_data in desired_files:
 
1323
            try:
 
1324
                weave = self.weave_store.get_weave(file_id, transaction)
 
1325
            except errors.NoSuchFile:
 
1326
                raise errors.NoSuchIdInRepository(self, file_id)
 
1327
            yield callable_data, weave.get_lines(revision_id)
 
1328
 
 
1329
    def _generate_text_key_index(self, text_key_references=None,
 
1330
        ancestors=None):
 
1331
        """Generate a new text key index for the repository.
 
1332
 
 
1333
        This is an expensive function that will take considerable time to run.
 
1334
 
 
1335
        :return: A dict mapping text keys ((file_id, revision_id) tuples) to a
 
1336
            list of parents, also text keys. When a given key has no parents,
 
1337
            the parents list will be [NULL_REVISION].
 
1338
        """
 
1339
        # All revisions, to find inventory parents.
 
1340
        if ancestors is None:
 
1341
            # self.get_revision_graph_with_ghosts().get_ancestors() wasn't
 
1342
            # returning any ghosts anyway.
 
1343
            ancestors = self.get_revision_graph()
 
1344
        if text_key_references is None:
 
1345
            text_key_references = self.find_text_key_references()
 
1346
        pb = ui.ui_factory.nested_progress_bar()
 
1347
        try:
 
1348
            return self._do_generate_text_key_index(ancestors,
 
1349
                text_key_references, pb)
 
1350
        finally:
 
1351
            pb.finished()
 
1352
 
 
1353
    def _do_generate_text_key_index(self, ancestors, text_key_references, pb):
 
1354
        """Helper for _generate_text_key_index to avoid deep nesting."""
 
1355
        revision_order = tsort.topo_sort(ancestors)
 
1356
        invalid_keys = set()
 
1357
        revision_keys = {}
 
1358
        for revision_id in revision_order:
 
1359
            revision_keys[revision_id] = set()
 
1360
        text_count = len(text_key_references)
 
1361
        # a cache of the text keys to allow reuse; costs a dict of all the
 
1362
        # keys, but saves a 2-tuple for every child of a given key.
 
1363
        text_key_cache = {}
 
1364
        for text_key, valid in text_key_references.iteritems():
 
1365
            if not valid:
 
1366
                invalid_keys.add(text_key)
 
1367
            else:
 
1368
                revision_keys[text_key[1]].add(text_key)
 
1369
            text_key_cache[text_key] = text_key
 
1370
        del text_key_references
 
1371
        text_index = {}
 
1372
        text_graph = graph.Graph(graph.DictParentsProvider(text_index))
 
1373
        NULL_REVISION = _mod_revision.NULL_REVISION
 
1374
        # Set a cache with a size of 10 - this suffices for bzr.dev but may be
 
1375
        # too small for large or very branchy trees. However, for 55K path
 
1376
        # trees, it would be easy to use too much memory trivially. Ideally we
 
1377
        # could gauge this by looking at available real memory etc, but this is
 
1378
        # always a tricky proposition.
 
1379
        inventory_cache = lru_cache.LRUCache(10)
 
1380
        batch_size = 10 # should be ~150MB on a 55K path tree
 
1381
        batch_count = len(revision_order) / batch_size + 1
 
1382
        processed_texts = 0
 
1383
        pb.update("Calculating text parents.", processed_texts, text_count)
 
1384
        for offset in xrange(batch_count):
 
1385
            to_query = revision_order[offset * batch_size:(offset + 1) *
 
1386
                batch_size]
 
1387
            if not to_query:
 
1388
                break
 
1389
            for rev_tree in self.revision_trees(to_query):
 
1390
                revision_id = rev_tree.get_revision_id()
 
1391
                parent_ids = ancestors[revision_id]
 
1392
                for text_key in revision_keys[revision_id]:
 
1393
                    pb.update("Calculating text parents.", processed_texts)
 
1394
                    processed_texts += 1
 
1395
                    candidate_parents = []
 
1396
                    for parent_id in parent_ids:
 
1397
                        parent_text_key = (text_key[0], parent_id)
 
1398
                        try:
 
1399
                            check_parent = parent_text_key not in \
 
1400
                                revision_keys[parent_id]
 
1401
                        except KeyError:
 
1402
                            # the parent parent_id is a ghost:
 
1403
                            check_parent = False
 
1404
                            # truncate the derived graph against this ghost.
 
1405
                            parent_text_key = None
 
1406
                        if check_parent:
 
1407
                            # look at the parent commit details inventories to
 
1408
                            # determine possible candidates in the per file graph.
 
1409
                            # TODO: cache here.
 
1410
                            try:
 
1411
                                inv = inventory_cache[parent_id]
 
1412
                            except KeyError:
 
1413
                                inv = self.revision_tree(parent_id).inventory
 
1414
                                inventory_cache[parent_id] = inv
 
1415
                            parent_entry = inv._byid.get(text_key[0], None)
 
1416
                            if parent_entry is not None:
 
1417
                                parent_text_key = (
 
1418
                                    text_key[0], parent_entry.revision)
 
1419
                            else:
 
1420
                                parent_text_key = None
 
1421
                        if parent_text_key is not None:
 
1422
                            candidate_parents.append(
 
1423
                                text_key_cache[parent_text_key])
 
1424
                    parent_heads = text_graph.heads(candidate_parents)
 
1425
                    new_parents = list(parent_heads)
 
1426
                    new_parents.sort(key=lambda x:candidate_parents.index(x))
 
1427
                    if new_parents == []:
 
1428
                        new_parents = [NULL_REVISION]
 
1429
                    text_index[text_key] = new_parents
 
1430
 
 
1431
        for text_key in invalid_keys:
 
1432
            text_index[text_key] = [NULL_REVISION]
 
1433
        return text_index
 
1434
 
 
1435
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
 
1436
        """Get an iterable listing the keys of all the data introduced by a set
 
1437
        of revision IDs.
 
1438
 
 
1439
        The keys will be ordered so that the corresponding items can be safely
 
1440
        fetched and inserted in that order.
 
1441
 
 
1442
        :returns: An iterable producing tuples of (knit-kind, file-id,
 
1443
            versions).  knit-kind is one of 'file', 'inventory', 'signatures',
 
1444
            'revisions'.  file-id is None unless knit-kind is 'file'.
 
1445
        """
 
1446
        # XXX: it's a bit weird to control the inventory weave caching in this
 
1447
        # generator.  Ideally the caching would be done in fetch.py I think.  Or
 
1448
        # maybe this generator should explicitly have the contract that it
 
1449
        # should not be iterated until the previously yielded item has been
 
1450
        # processed?
 
1451
        self.lock_read()
 
1452
        inv_w = self.get_inventory_weave()
 
1453
        inv_w.enable_cache()
 
1454
 
 
1455
        # file ids that changed
 
1456
        file_ids = self.fileids_altered_by_revision_ids(revision_ids)
 
1457
        count = 0
 
1458
        num_file_ids = len(file_ids)
 
1459
        for file_id, altered_versions in file_ids.iteritems():
 
1460
            if _files_pb is not None:
 
1461
                _files_pb.update("fetch texts", count, num_file_ids)
 
1462
            count += 1
 
1463
            yield ("file", file_id, altered_versions)
 
1464
        # We're done with the files_pb.  Note that it finished by the caller,
 
1465
        # just as it was created by the caller.
 
1466
        del _files_pb
 
1467
 
 
1468
        # inventory
 
1469
        yield ("inventory", None, revision_ids)
 
1470
        inv_w.clear_cache()
 
1471
 
 
1472
        # signatures
 
1473
        revisions_with_signatures = set()
 
1474
        for rev_id in revision_ids:
 
1475
            try:
 
1476
                self.get_signature_text(rev_id)
 
1477
            except errors.NoSuchRevision:
 
1478
                # not signed.
 
1479
                pass
 
1480
            else:
 
1481
                revisions_with_signatures.add(rev_id)
 
1482
        self.unlock()
 
1483
        yield ("signatures", None, revisions_with_signatures)
 
1484
 
 
1485
        # revisions
 
1486
        yield ("revisions", None, revision_ids)
 
1487
 
 
1488
    @needs_read_lock
 
1489
    def get_inventory_weave(self):
 
1490
        return self.control_weaves.get_weave('inventory',
 
1491
            self.get_transaction())
 
1492
 
 
1493
    @needs_read_lock
 
1494
    def get_inventory(self, revision_id):
 
1495
        """Get Inventory object by revision id."""
 
1496
        return self.iter_inventories([revision_id]).next()
 
1497
 
 
1498
    def iter_inventories(self, revision_ids):
 
1499
        """Get many inventories by revision_ids.
 
1500
 
 
1501
        This will buffer some or all of the texts used in constructing the
 
1502
        inventories in memory, but will only parse a single inventory at a
 
1503
        time.
 
1504
 
 
1505
        :return: An iterator of inventories.
 
1506
        """
 
1507
        assert None not in revision_ids
 
1508
        assert _mod_revision.NULL_REVISION not in revision_ids
 
1509
        return self._iter_inventories(revision_ids)
 
1510
 
 
1511
    def _iter_inventories(self, revision_ids):
 
1512
        """single-document based inventory iteration."""
 
1513
        texts = self.get_inventory_weave().get_texts(revision_ids)
 
1514
        for text, revision_id in zip(texts, revision_ids):
 
1515
            yield self.deserialise_inventory(revision_id, text)
 
1516
 
 
1517
    def deserialise_inventory(self, revision_id, xml):
 
1518
        """Transform the xml into an inventory object. 
 
1519
 
 
1520
        :param revision_id: The expected revision id of the inventory.
 
1521
        :param xml: A serialised inventory.
 
1522
        """
 
1523
        result = self._serializer.read_inventory_from_string(xml, revision_id)
 
1524
        if result.revision_id != revision_id:
 
1525
            raise AssertionError('revision id mismatch %s != %s' % (
 
1526
                result.revision_id, revision_id))
 
1527
        return result
 
1528
 
 
1529
    def serialise_inventory(self, inv):
 
1530
        return self._serializer.write_inventory_to_string(inv)
 
1531
 
 
1532
    def _serialise_inventory_to_lines(self, inv):
 
1533
        return self._serializer.write_inventory_to_lines(inv)
 
1534
 
 
1535
    def get_serializer_format(self):
 
1536
        return self._serializer.format_num
 
1537
 
 
1538
    @needs_read_lock
 
1539
    def get_inventory_xml(self, revision_id):
 
1540
        """Get inventory XML as a file object."""
 
1541
        try:
 
1542
            assert isinstance(revision_id, str), type(revision_id)
 
1543
            iw = self.get_inventory_weave()
 
1544
            return iw.get_text(revision_id)
 
1545
        except IndexError:
 
1546
            raise errors.HistoryMissing(self, 'inventory', revision_id)
 
1547
 
 
1548
    @needs_read_lock
 
1549
    def get_inventory_sha1(self, revision_id):
 
1550
        """Return the sha1 hash of the inventory entry
 
1551
        """
 
1552
        return self.get_revision(revision_id).inventory_sha1
 
1553
 
 
1554
    @needs_read_lock
 
1555
    def get_revision_graph(self, revision_id=None):
 
1556
        """Return a dictionary containing the revision graph.
 
1557
 
 
1558
        NB: This method should not be used as it accesses the entire graph all
 
1559
        at once, which is much more data than most operations should require.
 
1560
 
 
1561
        :param revision_id: The revision_id to get a graph from. If None, then
 
1562
        the entire revision graph is returned. This is a deprecated mode of
 
1563
        operation and will be removed in the future.
 
1564
        :return: a dictionary of revision_id->revision_parents_list.
 
1565
        """
 
1566
        raise NotImplementedError(self.get_revision_graph)
 
1567
 
 
1568
    @needs_read_lock
 
1569
    @deprecated_method(symbol_versioning.one_three)
 
1570
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
1571
        """Return a graph of the revisions with ghosts marked as applicable.
 
1572
 
 
1573
        :param revision_ids: an iterable of revisions to graph or None for all.
 
1574
        :return: a Graph object with the graph reachable from revision_ids.
 
1575
        """
 
1576
        if 'evil' in debug.debug_flags:
 
1577
            mutter_callsite(3,
 
1578
                "get_revision_graph_with_ghosts scales with size of history.")
 
1579
        result = deprecated_graph.Graph()
 
1580
        if not revision_ids:
 
1581
            pending = set(self.all_revision_ids())
 
1582
            required = set([])
 
1583
        else:
 
1584
            pending = set(revision_ids)
 
1585
            # special case NULL_REVISION
 
1586
            if _mod_revision.NULL_REVISION in pending:
 
1587
                pending.remove(_mod_revision.NULL_REVISION)
 
1588
            required = set(pending)
 
1589
        done = set([])
 
1590
        while len(pending):
 
1591
            revision_id = pending.pop()
 
1592
            try:
 
1593
                rev = self.get_revision(revision_id)
 
1594
            except errors.NoSuchRevision:
 
1595
                if revision_id in required:
 
1596
                    raise
 
1597
                # a ghost
 
1598
                result.add_ghost(revision_id)
 
1599
                continue
 
1600
            for parent_id in rev.parent_ids:
 
1601
                # is this queued or done ?
 
1602
                if (parent_id not in pending and
 
1603
                    parent_id not in done):
 
1604
                    # no, queue it.
 
1605
                    pending.add(parent_id)
 
1606
            result.add_node(revision_id, rev.parent_ids)
 
1607
            done.add(revision_id)
 
1608
        return result
 
1609
 
 
1610
    def _get_history_vf(self):
 
1611
        """Get a versionedfile whose history graph reflects all revisions.
 
1612
 
 
1613
        For weave repositories, this is the inventory weave.
 
1614
        """
 
1615
        return self.get_inventory_weave()
 
1616
 
985
1617
    def iter_reverse_revision_history(self, revision_id):
986
1618
        """Iterate backwards through revision ids in the lefthand history
987
1619
 
988
1620
        :param revision_id: The revision id to start with.  All its lefthand
989
1621
            ancestors will be traversed.
990
1622
        """
991
 
        graph = self.get_graph()
992
 
        stop_revisions = (None, _mod_revision.NULL_REVISION)
993
 
        return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
994
 
 
 
1623
        if revision_id in (None, _mod_revision.NULL_REVISION):
 
1624
            return
 
1625
        next_id = revision_id
 
1626
        versionedfile = self._get_history_vf()
 
1627
        while True:
 
1628
            yield next_id
 
1629
            parents = versionedfile.get_parents(next_id)
 
1630
            if len(parents) == 0:
 
1631
                return
 
1632
            else:
 
1633
                next_id = parents[0]
 
1634
 
 
1635
    @needs_read_lock
 
1636
    def get_revision_inventory(self, revision_id):
 
1637
        """Return inventory of a past revision."""
 
1638
        # TODO: Unify this with get_inventory()
 
1639
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
1640
        # must be the same as its revision, so this is trivial.
 
1641
        if revision_id is None:
 
1642
            # This does not make sense: if there is no revision,
 
1643
            # then it is the current tree inventory surely ?!
 
1644
            # and thus get_root_id() is something that looks at the last
 
1645
            # commit on the branch, and the get_root_id is an inventory check.
 
1646
            raise NotImplementedError
 
1647
            # return Inventory(self.get_root_id())
 
1648
        else:
 
1649
            return self.get_inventory(revision_id)
 
1650
 
 
1651
    @needs_read_lock
995
1652
    def is_shared(self):
996
1653
        """Return True if this repository is flagged as a shared repository."""
997
1654
        raise NotImplementedError(self.is_shared)
1011
1668
        for repositories to maintain loaded indices across multiple locks
1012
1669
        by checking inside their implementation of this method to see
1013
1670
        whether their indices are still valid. This depends of course on
1014
 
        the disk format being validatable in this manner. This method is
1015
 
        also called by the refresh_data() public interface to cause a refresh
1016
 
        to occur while in a write lock so that data inserted by a smart server
1017
 
        push operation is visible on the client's instance of the physical
1018
 
        repository.
 
1671
        the disk format being validatable in this manner.
1019
1672
        """
1020
1673
 
1021
1674
    @needs_read_lock
1022
1675
    def revision_tree(self, revision_id):
1023
1676
        """Return Tree for a revision on this branch.
1024
1677
 
1025
 
        `revision_id` may be NULL_REVISION for the empty tree revision.
 
1678
        `revision_id` may be None for the empty tree revision.
1026
1679
        """
1027
 
        raise NotImplementedError(self.revision_tree)
 
1680
        # TODO: refactor this to use an existing revision object
 
1681
        # so we don't need to read it in twice.
 
1682
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
 
1683
            return RevisionTree(self, Inventory(root_id=None), 
 
1684
                                _mod_revision.NULL_REVISION)
 
1685
        else:
 
1686
            inv = self.get_revision_inventory(revision_id)
 
1687
            return RevisionTree(self, inv, revision_id)
1028
1688
 
 
1689
    @needs_read_lock
1029
1690
    def revision_trees(self, revision_ids):
1030
 
        """Return Trees for revisions in this repository.
 
1691
        """Return Tree for a revision on this branch.
1031
1692
 
1032
 
        :param revision_ids: a sequence of revision-ids;
1033
 
          a revision-id may not be None or 'null:'
1034
 
        """
1035
 
        raise NotImplementedError(self.revision_trees)
 
1693
        `revision_id` may not be None or 'null:'"""
 
1694
        inventories = self.iter_inventories(revision_ids)
 
1695
        for inv in inventories:
 
1696
            yield RevisionTree(self, inv, inv.revision_id)
1036
1697
 
1037
1698
    @needs_read_lock
1038
 
    @symbol_versioning.deprecated_method(
1039
 
        symbol_versioning.deprecated_in((2, 4, 0)))
1040
1699
    def get_ancestry(self, revision_id, topo_sorted=True):
1041
1700
        """Return a list of revision-ids integrated by a revision.
1042
1701
 
1043
 
        The first element of the list is always None, indicating the origin
1044
 
        revision.  This might change when we have history horizons, or
 
1702
        The first element of the list is always None, indicating the origin 
 
1703
        revision.  This might change when we have history horizons, or 
1045
1704
        perhaps we should have a new API.
1046
 
 
 
1705
        
1047
1706
        This is topologically sorted.
1048
1707
        """
1049
 
        if 'evil' in debug.debug_flags:
1050
 
            mutter_callsite(2, "get_ancestry is linear with history.")
1051
1708
        if _mod_revision.is_null(revision_id):
1052
1709
            return [None]
1053
1710
        if not self.has_revision(revision_id):
1054
1711
            raise errors.NoSuchRevision(self, revision_id)
1055
 
        graph = self.get_graph()
1056
 
        keys = set()
1057
 
        search = graph._make_breadth_first_searcher([revision_id])
1058
 
        while True:
1059
 
            try:
1060
 
                found, ghosts = search.next_with_ghosts()
1061
 
            except StopIteration:
1062
 
                break
1063
 
            keys.update(found)
1064
 
        if _mod_revision.NULL_REVISION in keys:
1065
 
            keys.remove(_mod_revision.NULL_REVISION)
1066
 
        if topo_sorted:
1067
 
            parent_map = graph.get_parent_map(keys)
1068
 
            keys = tsort.topo_sort(parent_map)
1069
 
        return [None] + list(keys)
 
1712
        w = self.get_inventory_weave()
 
1713
        candidates = w.get_ancestry(revision_id, topo_sorted)
 
1714
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
1070
1715
 
1071
 
    def pack(self, hint=None, clean_obsolete_packs=False):
 
1716
    def pack(self):
1072
1717
        """Compress the data within the repository.
1073
1718
 
1074
1719
        This operation only makes sense for some repository types. For other
1075
1720
        types it should be a no-op that just returns.
1076
1721
 
1077
1722
        This stub method does not require a lock, but subclasses should use
1078
 
        @needs_write_lock as this is a long running call it's reasonable to
 
1723
        @needs_write_lock as this is a long running call its reasonable to 
1079
1724
        implicitly lock for the user.
1080
 
 
1081
 
        :param hint: If not supplied, the whole repository is packed.
1082
 
            If supplied, the repository may use the hint parameter as a
1083
 
            hint for the parts of the repository to pack. A hint can be
1084
 
            obtained from the result of commit_write_group(). Out of
1085
 
            date hints are simply ignored, because concurrent operations
1086
 
            can obsolete them rapidly.
1087
 
 
1088
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
1089
 
            the pack operation.
1090
 
        """
 
1725
        """
 
1726
 
 
1727
    @needs_read_lock
 
1728
    def print_file(self, file, revision_id):
 
1729
        """Print `file` to stdout.
 
1730
        
 
1731
        FIXME RBC 20060125 as John Meinel points out this is a bad api
 
1732
        - it writes to stdout, it assumes that that is valid etc. Fix
 
1733
        by creating a new more flexible convenience function.
 
1734
        """
 
1735
        tree = self.revision_tree(revision_id)
 
1736
        # use inventory as it was in that revision
 
1737
        file_id = tree.inventory.path2id(file)
 
1738
        if not file_id:
 
1739
            # TODO: jam 20060427 Write a test for this code path
 
1740
            #       it had a bug in it, and was raising the wrong
 
1741
            #       exception.
 
1742
            raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
 
1743
        tree.print_file(file_id)
1091
1744
 
1092
1745
    def get_transaction(self):
1093
1746
        return self.control_files.get_transaction()
1094
1747
 
1095
 
    def get_parent_map(self, revision_ids):
1096
 
        """See graph.StackedParentsProvider.get_parent_map"""
1097
 
        raise NotImplementedError(self.get_parent_map)
1098
 
 
1099
 
    def _get_parent_map_no_fallbacks(self, revision_ids):
1100
 
        """Same as Repository.get_parent_map except doesn't query fallbacks."""
1101
 
        # revisions index works in keys; this just works in revisions
1102
 
        # therefore wrap and unwrap
1103
 
        query_keys = []
1104
 
        result = {}
1105
 
        for revision_id in revision_ids:
 
1748
    def revision_parents(self, revision_id):
 
1749
        return self.get_inventory_weave().parent_names(revision_id)
 
1750
 
 
1751
    @deprecated_method(symbol_versioning.one_one)
 
1752
    def get_parents(self, revision_ids):
 
1753
        """See StackedParentsProvider.get_parents"""
 
1754
        parent_map = self.get_parent_map(revision_ids)
 
1755
        return [parent_map.get(r, None) for r in revision_ids]
 
1756
 
 
1757
    def get_parent_map(self, keys):
 
1758
        """See graph._StackedParentsProvider.get_parent_map"""
 
1759
        parent_map = {}
 
1760
        for revision_id in keys:
1106
1761
            if revision_id == _mod_revision.NULL_REVISION:
1107
 
                result[revision_id] = ()
1108
 
            elif revision_id is None:
1109
 
                raise ValueError('get_parent_map(None) is not valid')
1110
 
            else:
1111
 
                query_keys.append((revision_id ,))
1112
 
        vf = self.revisions.without_fallbacks()
1113
 
        for ((revision_id,), parent_keys) in \
1114
 
                vf.get_parent_map(query_keys).iteritems():
1115
 
            if parent_keys:
1116
 
                result[revision_id] = tuple([parent_revid
1117
 
                    for (parent_revid,) in parent_keys])
1118
 
            else:
1119
 
                result[revision_id] = (_mod_revision.NULL_REVISION,)
1120
 
        return result
 
1762
                parent_map[revision_id] = ()
 
1763
            else:
 
1764
                try:
 
1765
                    parent_id_list = self.get_revision(revision_id).parent_ids
 
1766
                except errors.NoSuchRevision:
 
1767
                    pass
 
1768
                else:
 
1769
                    if len(parent_id_list) == 0:
 
1770
                        parent_ids = (_mod_revision.NULL_REVISION,)
 
1771
                    else:
 
1772
                        parent_ids = tuple(parent_id_list)
 
1773
                    parent_map[revision_id] = parent_ids
 
1774
        return parent_map
1121
1775
 
1122
1776
    def _make_parents_provider(self):
1123
 
        if not self._format.supports_external_lookups:
1124
 
            return self
1125
 
        return graph.StackedParentsProvider(_LazyListJoin(
1126
 
            [self._make_parents_provider_unstacked()],
1127
 
            self._fallback_repositories))
1128
 
 
1129
 
    def _make_parents_provider_unstacked(self):
1130
 
        return graph.CallableToParentsProviderAdapter(
1131
 
            self._get_parent_map_no_fallbacks)
1132
 
 
1133
 
    @needs_read_lock
1134
 
    def get_known_graph_ancestry(self, revision_ids):
1135
 
        """Return the known graph for a set of revision ids and their ancestors.
1136
 
        """
1137
 
        raise NotImplementedError(self.get_known_graph_ancestry)
1138
 
 
1139
 
    def get_file_graph(self):
1140
 
        """Return the graph walker for files."""
1141
 
        raise NotImplementedError(self.get_file_graph)
 
1777
        return self
1142
1778
 
1143
1779
    def get_graph(self, other_repository=None):
1144
1780
        """Return the graph walker for this repository format"""
1145
1781
        parents_provider = self._make_parents_provider()
1146
1782
        if (other_repository is not None and
1147
1783
            not self.has_same_location(other_repository)):
1148
 
            parents_provider = graph.StackedParentsProvider(
 
1784
            parents_provider = graph._StackedParentsProvider(
1149
1785
                [parents_provider, other_repository._make_parents_provider()])
1150
1786
        return graph.Graph(parents_provider)
1151
1787
 
 
1788
    def _get_versioned_file_checker(self):
 
1789
        """Return an object suitable for checking versioned files."""
 
1790
        return _VersionedFileChecker(self)
 
1791
 
1152
1792
    def revision_ids_to_search_result(self, result_set):
1153
1793
        """Convert a set of revision ids to a graph SearchResult."""
1154
1794
        result_parents = set()
1173
1813
                          working trees.
1174
1814
        """
1175
1815
        raise NotImplementedError(self.set_make_working_trees)
1176
 
 
 
1816
    
1177
1817
    def make_working_trees(self):
1178
1818
        """Returns the policy for making working trees on new branches."""
1179
1819
        raise NotImplementedError(self.make_working_trees)
1180
1820
 
1181
1821
    @needs_write_lock
1182
1822
    def sign_revision(self, revision_id, gpg_strategy):
1183
 
        testament = _mod_testament.Testament.from_revision(self, revision_id)
1184
 
        plaintext = testament.as_short_text()
 
1823
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
1185
1824
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1186
1825
 
1187
1826
    @needs_read_lock
1188
 
    def verify_revision(self, revision_id, gpg_strategy):
1189
 
        """Verify the signature on a revision.
1190
 
        
1191
 
        :param revision_id: the revision to verify
1192
 
        :gpg_strategy: the GPGStrategy object to used
1193
 
        
1194
 
        :return: gpg.SIGNATURE_VALID or a failed SIGNATURE_ value
1195
 
        """
1196
 
        if not self.has_signature_for_revision_id(revision_id):
1197
 
            return gpg.SIGNATURE_NOT_SIGNED, None
1198
 
        signature = self.get_signature_text(revision_id)
1199
 
 
1200
 
        testament = _mod_testament.Testament.from_revision(self, revision_id)
1201
 
        plaintext = testament.as_short_text()
1202
 
 
1203
 
        return gpg_strategy.verify(signature, plaintext)
1204
 
 
1205
1827
    def has_signature_for_revision_id(self, revision_id):
1206
1828
        """Query for a revision signature for revision_id in the repository."""
1207
 
        raise NotImplementedError(self.has_signature_for_revision_id)
 
1829
        return self._revision_store.has_signature(revision_id,
 
1830
                                                  self.get_transaction())
1208
1831
 
 
1832
    @needs_read_lock
1209
1833
    def get_signature_text(self, revision_id):
1210
1834
        """Return the text for a signature."""
1211
 
        raise NotImplementedError(self.get_signature_text)
 
1835
        return self._revision_store.get_signature_text(revision_id,
 
1836
                                                       self.get_transaction())
1212
1837
 
1213
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1838
    @needs_read_lock
 
1839
    def check(self, revision_ids=None):
1214
1840
        """Check consistency of all history of given revision_ids.
1215
1841
 
1216
1842
        Different repository implementations should override _check().
1217
1843
 
1218
1844
        :param revision_ids: A non-empty list of revision_ids whose ancestry
1219
1845
             will be checked.  Typically the last revision_id of a branch.
1220
 
        :param callback_refs: A dict of check-refs to resolve and callback
1221
 
            the check/_check method on the items listed as wanting the ref.
1222
 
            see bzrlib.check.
1223
 
        :param check_repo: If False do not check the repository contents, just 
1224
 
            calculate the data callback_refs requires and call them back.
1225
1846
        """
1226
 
        return self._check(revision_ids=revision_ids, callback_refs=callback_refs,
1227
 
            check_repo=check_repo)
1228
 
 
1229
 
    def _check(self, revision_ids=None, callback_refs=None, check_repo=True):
1230
 
        raise NotImplementedError(self.check)
1231
 
 
1232
 
    def _warn_if_deprecated(self, branch=None):
1233
 
        if not self._format.is_deprecated():
1234
 
            return
 
1847
        return self._check(revision_ids)
 
1848
 
 
1849
    def _check(self, revision_ids):
 
1850
        result = check.Check(self)
 
1851
        result.check()
 
1852
        return result
 
1853
 
 
1854
    def _warn_if_deprecated(self):
1235
1855
        global _deprecation_warning_done
1236
1856
        if _deprecation_warning_done:
1237
1857
            return
1238
 
        try:
1239
 
            if branch is None:
1240
 
                conf = config.GlobalConfig()
1241
 
            else:
1242
 
                conf = branch.get_config()
1243
 
            if conf.suppress_warning('format_deprecation'):
1244
 
                return
1245
 
            warning("Format %s for %s is deprecated -"
1246
 
                    " please use 'bzr upgrade' to get better performance"
1247
 
                    % (self._format, self.bzrdir.transport.base))
1248
 
        finally:
1249
 
            _deprecation_warning_done = True
 
1858
        _deprecation_warning_done = True
 
1859
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
1860
                % (self._format, self.bzrdir.transport.base))
1250
1861
 
1251
1862
    def supports_rich_root(self):
1252
1863
        return self._format.rich_root_data
1266
1877
                    revision_id.decode('ascii')
1267
1878
                except UnicodeDecodeError:
1268
1879
                    raise errors.NonAsciiRevisionId(method, self)
 
1880
    
 
1881
    def revision_graph_can_have_wrong_parents(self):
 
1882
        """Is it possible for this repository to have a revision graph with
 
1883
        incorrect parents?
 
1884
 
 
1885
        If True, then this repository must also implement
 
1886
        _find_inconsistent_revision_parents so that check and reconcile can
 
1887
        check for inconsistencies before proceeding with other checks that may
 
1888
        depend on the revision index being consistent.
 
1889
        """
 
1890
        raise NotImplementedError(self.revision_graph_can_have_wrong_parents)
 
1891
 
 
1892
 
 
1893
# remove these delegates a while after bzr 0.15
 
1894
def __make_delegated(name, from_module):
 
1895
    def _deprecated_repository_forwarder():
 
1896
        symbol_versioning.warn('%s moved to %s in bzr 0.15'
 
1897
            % (name, from_module),
 
1898
            DeprecationWarning,
 
1899
            stacklevel=2)
 
1900
        m = __import__(from_module, globals(), locals(), [name])
 
1901
        try:
 
1902
            return getattr(m, name)
 
1903
        except AttributeError:
 
1904
            raise AttributeError('module %s has no name %s'
 
1905
                    % (m, name))
 
1906
    globals()[name] = _deprecated_repository_forwarder
 
1907
 
 
1908
for _name in [
 
1909
        'AllInOneRepository',
 
1910
        'WeaveMetaDirRepository',
 
1911
        'PreSplitOutRepositoryFormat',
 
1912
        'RepositoryFormat4',
 
1913
        'RepositoryFormat5',
 
1914
        'RepositoryFormat6',
 
1915
        'RepositoryFormat7',
 
1916
        ]:
 
1917
    __make_delegated(_name, 'bzrlib.repofmt.weaverepo')
 
1918
 
 
1919
for _name in [
 
1920
        'KnitRepository',
 
1921
        'RepositoryFormatKnit',
 
1922
        'RepositoryFormatKnit1',
 
1923
        ]:
 
1924
    __make_delegated(_name, 'bzrlib.repofmt.knitrepo')
 
1925
 
 
1926
 
 
1927
def install_revision(repository, rev, revision_tree):
 
1928
    """Install all revision data into a repository."""
 
1929
    install_revisions(repository, [(rev, revision_tree, None)])
 
1930
 
 
1931
 
 
1932
def install_revisions(repository, iterable, num_revisions=None, pb=None):
 
1933
    """Install all revision data into a repository.
 
1934
 
 
1935
    Accepts an iterable of revision, tree, signature tuples.  The signature
 
1936
    may be None.
 
1937
    """
 
1938
    repository.start_write_group()
 
1939
    try:
 
1940
        for n, (revision, revision_tree, signature) in enumerate(iterable):
 
1941
            _install_revision(repository, revision, revision_tree, signature)
 
1942
            if pb is not None:
 
1943
                pb.update('Transferring revisions', n + 1, num_revisions)
 
1944
    except:
 
1945
        repository.abort_write_group()
 
1946
        raise
 
1947
    else:
 
1948
        repository.commit_write_group()
 
1949
 
 
1950
 
 
1951
def _install_revision(repository, rev, revision_tree, signature):
 
1952
    """Install all revision data into a repository."""
 
1953
    present_parents = []
 
1954
    parent_trees = {}
 
1955
    for p_id in rev.parent_ids:
 
1956
        if repository.has_revision(p_id):
 
1957
            present_parents.append(p_id)
 
1958
            parent_trees[p_id] = repository.revision_tree(p_id)
 
1959
        else:
 
1960
            parent_trees[p_id] = repository.revision_tree(None)
 
1961
 
 
1962
    inv = revision_tree.inventory
 
1963
    entries = inv.iter_entries()
 
1964
    # backwards compatibility hack: skip the root id.
 
1965
    if not repository.supports_rich_root():
 
1966
        path, root = entries.next()
 
1967
        if root.revision != rev.revision_id:
 
1968
            raise errors.IncompatibleRevision(repr(repository))
 
1969
    # Add the texts that are not already present
 
1970
    for path, ie in entries:
 
1971
        w = repository.weave_store.get_weave_or_empty(ie.file_id,
 
1972
                repository.get_transaction())
 
1973
        if ie.revision not in w:
 
1974
            text_parents = []
 
1975
            # FIXME: TODO: The following loop *may* be overlapping/duplicate
 
1976
            # with InventoryEntry.find_previous_heads(). if it is, then there
 
1977
            # is a latent bug here where the parents may have ancestors of each
 
1978
            # other. RBC, AB
 
1979
            for revision, tree in parent_trees.iteritems():
 
1980
                if ie.file_id not in tree:
 
1981
                    continue
 
1982
                parent_id = tree.inventory[ie.file_id].revision
 
1983
                if parent_id in text_parents:
 
1984
                    continue
 
1985
                text_parents.append(parent_id)
 
1986
                    
 
1987
            vfile = repository.weave_store.get_weave_or_empty(ie.file_id, 
 
1988
                repository.get_transaction())
 
1989
            lines = revision_tree.get_file(ie.file_id).readlines()
 
1990
            vfile.add_lines(rev.revision_id, text_parents, lines)
 
1991
    try:
 
1992
        # install the inventory
 
1993
        repository.add_inventory(rev.revision_id, inv, present_parents)
 
1994
    except errors.RevisionAlreadyPresent:
 
1995
        pass
 
1996
    if signature is not None:
 
1997
        repository.add_signature_text(rev.revision_id, signature)
 
1998
    repository.add_revision(rev.revision_id, rev, inv)
1269
1999
 
1270
2000
 
1271
2001
class MetaDirRepository(Repository):
1272
 
    """Repositories in the new meta-dir layout.
1273
 
 
1274
 
    :ivar _transport: Transport for access to repository control files,
1275
 
        typically pointing to .bzr/repository.
1276
 
    """
1277
 
 
1278
 
    def __init__(self, _format, a_bzrdir, control_files):
1279
 
        super(MetaDirRepository, self).__init__(_format, a_bzrdir, control_files)
1280
 
        self._transport = control_files._transport
1281
 
 
 
2002
    """Repositories in the new meta-dir layout."""
 
2003
 
 
2004
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
 
2005
        super(MetaDirRepository, self).__init__(_format,
 
2006
                                                a_bzrdir,
 
2007
                                                control_files,
 
2008
                                                _revision_store,
 
2009
                                                control_store,
 
2010
                                                text_store)
 
2011
        dir_mode = self.control_files._dir_mode
 
2012
        file_mode = self.control_files._file_mode
 
2013
 
 
2014
    @needs_read_lock
1282
2015
    def is_shared(self):
1283
2016
        """Return True if this repository is flagged as a shared repository."""
1284
 
        return self._transport.has('shared-storage')
 
2017
        return self.control_files._transport.has('shared-storage')
1285
2018
 
1286
2019
    @needs_write_lock
1287
2020
    def set_make_working_trees(self, new_value):
1295
2028
        """
1296
2029
        if new_value:
1297
2030
            try:
1298
 
                self._transport.delete('no-working-trees')
 
2031
                self.control_files._transport.delete('no-working-trees')
1299
2032
            except errors.NoSuchFile:
1300
2033
                pass
1301
2034
        else:
1302
 
            self._transport.put_bytes('no-working-trees', '',
1303
 
                mode=self.bzrdir._get_file_mode())
1304
 
 
 
2035
            self.control_files.put_utf8('no-working-trees', '')
 
2036
    
1305
2037
    def make_working_trees(self):
1306
2038
        """Returns the policy for making working trees on new branches."""
1307
 
        return not self._transport.has('no-working-trees')
1308
 
 
1309
 
 
1310
 
class RepositoryFormatRegistry(controldir.ControlComponentFormatRegistry):
1311
 
    """Repository format registry."""
1312
 
 
1313
 
    def get_default(self):
1314
 
        """Return the current default format."""
1315
 
        return controldir.format_registry.make_bzrdir('default').repository_format
1316
 
 
1317
 
 
1318
 
network_format_registry = registry.FormatRegistry()
1319
 
"""Registry of formats indexed by their network name.
1320
 
 
1321
 
The network name for a repository format is an identifier that can be used when
1322
 
referring to formats with smart server operations. See
1323
 
RepositoryFormat.network_name() for more detail.
1324
 
"""
1325
 
 
1326
 
 
1327
 
format_registry = RepositoryFormatRegistry(network_format_registry)
1328
 
"""Registry of formats, indexed by their BzrDirMetaFormat format string.
 
2039
        return not self.control_files._transport.has('no-working-trees')
 
2040
 
 
2041
 
 
2042
class RepositoryFormatRegistry(registry.Registry):
 
2043
    """Registry of RepositoryFormats."""
 
2044
 
 
2045
    def get(self, format_string):
 
2046
        r = registry.Registry.get(self, format_string)
 
2047
        if callable(r):
 
2048
            r = r()
 
2049
        return r
 
2050
    
 
2051
 
 
2052
format_registry = RepositoryFormatRegistry()
 
2053
"""Registry of formats, indexed by their identifying format string.
1329
2054
 
1330
2055
This can contain either format instances themselves, or classes/factories that
1331
2056
can be called to obtain one.
1335
2060
#####################################################################
1336
2061
# Repository Formats
1337
2062
 
1338
 
class RepositoryFormat(controldir.ControlComponentFormat):
 
2063
class RepositoryFormat(object):
1339
2064
    """A repository format.
1340
2065
 
1341
 
    Formats provide four things:
 
2066
    Formats provide three things:
1342
2067
     * An initialization routine to construct repository data on disk.
1343
 
     * a optional format string which is used when the BzrDir supports
1344
 
       versioned children.
 
2068
     * a format string which is used when the BzrDir supports versioned
 
2069
       children.
1345
2070
     * an open routine which returns a Repository instance.
1346
 
     * A network name for referring to the format in smart server RPC
1347
 
       methods.
1348
2071
 
1349
2072
    There is one and only one Format subclass for each on-disk format. But
1350
2073
    there can be one Repository subclass that is used for several different
1351
2074
    formats. The _format attribute on a Repository instance can be used to
1352
2075
    determine the disk format.
1353
2076
 
1354
 
    Formats are placed in a registry by their format string for reference
1355
 
    during opening. These should be subclasses of RepositoryFormat for
1356
 
    consistency.
 
2077
    Formats are placed in an dict by their format string for reference 
 
2078
    during opening. These should be subclasses of RepositoryFormat
 
2079
    for consistency.
1357
2080
 
1358
2081
    Once a format is deprecated, just deprecate the initialize and open
1359
 
    methods on the format class. Do not deprecate the object, as the
1360
 
    object may be created even when a repository instance hasn't been
1361
 
    created.
 
2082
    methods on the format class. Do not deprecate the object, as the 
 
2083
    object will be created every system load.
1362
2084
 
1363
2085
    Common instance attributes:
1364
 
    _matchingbzrdir - the controldir format that the repository format was
 
2086
    _matchingbzrdir - the bzrdir format that the repository format was
1365
2087
    originally written to work with. This can be used if manually
1366
2088
    constructing a bzrdir and repository, or more commonly for test suite
1367
2089
    parameterization.
1373
2095
    # Can this repository be given external locations to lookup additional
1374
2096
    # data. Set to True or False in derived classes.
1375
2097
    supports_external_lookups = None
1376
 
    # Does this format support CHK bytestring lookups. Set to True or False in
1377
 
    # derived classes.
1378
 
    supports_chks = None
1379
 
    # Should fetch trigger a reconcile after the fetch? Only needed for
1380
 
    # some repository formats that can suffer internal inconsistencies.
1381
 
    _fetch_reconcile = False
1382
 
    # Does this format have < O(tree_size) delta generation. Used to hint what
1383
 
    # code path for commit, amongst other things.
1384
 
    fast_deltas = None
1385
 
    # Does doing a pack operation compress data? Useful for the pack UI command
1386
 
    # (so if there is one pack, the operation can still proceed because it may
1387
 
    # help), and for fetching when data won't have come from the same
1388
 
    # compressor.
1389
 
    pack_compresses = False
1390
 
    # Does the repository storage understand references to trees?
1391
 
    supports_tree_reference = None
1392
 
    # Is the format experimental ?
1393
 
    experimental = False
1394
 
    # Does this repository format escape funky characters, or does it create
1395
 
    # files with similar names as the versioned files in its contents on disk
1396
 
    # ?
1397
 
    supports_funky_characters = None
1398
 
    # Does this repository format support leaving locks?
1399
 
    supports_leaving_lock = None
1400
 
    # Does this format support the full VersionedFiles interface?
1401
 
    supports_full_versioned_files = None
1402
 
    # Does this format support signing revision signatures?
1403
 
    supports_revision_signatures = True
1404
 
    # Can the revision graph have incorrect parents?
1405
 
    revision_graph_can_have_wrong_parents = None
1406
 
    # Does this format support rich root data?
1407
 
    rich_root_data = None
1408
 
    # Does this format support explicitly versioned directories?
1409
 
    supports_versioned_directories = None
1410
 
    # Can other repositories be nested into one of this format?
1411
 
    supports_nesting_repositories = None
1412
2098
 
1413
 
    def __repr__(self):
1414
 
        return "%s()" % self.__class__.__name__
 
2099
    def __str__(self):
 
2100
        return "<%s>" % self.__class__.__name__
1415
2101
 
1416
2102
    def __eq__(self, other):
1417
2103
        # format objects are generally stateless
1423
2109
    @classmethod
1424
2110
    def find_format(klass, a_bzrdir):
1425
2111
        """Return the format for the repository object in a_bzrdir.
1426
 
 
 
2112
        
1427
2113
        This is used by bzr native formats that have a "format" file in
1428
 
        the repository.  Other methods may be used by different types of
 
2114
        the repository.  Other methods may be used by different types of 
1429
2115
        control directory.
1430
2116
        """
1431
2117
        try:
1432
2118
            transport = a_bzrdir.get_repository_transport(None)
1433
 
            format_string = transport.get_bytes("format")
 
2119
            format_string = transport.get("format").read()
1434
2120
            return format_registry.get(format_string)
1435
2121
        except errors.NoSuchFile:
1436
2122
            raise errors.NoRepositoryPresent(a_bzrdir)
1439
2125
                                            kind='repository')
1440
2126
 
1441
2127
    @classmethod
1442
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1443
2128
    def register_format(klass, format):
1444
 
        format_registry.register(format)
 
2129
        format_registry.register(format.get_format_string(), format)
1445
2130
 
1446
2131
    @classmethod
1447
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1448
2132
    def unregister_format(klass, format):
1449
 
        format_registry.remove(format)
1450
 
 
 
2133
        format_registry.remove(format.get_format_string())
 
2134
    
1451
2135
    @classmethod
1452
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1453
2136
    def get_default_format(klass):
1454
2137
        """Return the current default format."""
1455
 
        return format_registry.get_default()
 
2138
        from bzrlib import bzrdir
 
2139
        return bzrdir.format_registry.make_bzrdir('default').repository_format
 
2140
 
 
2141
    def _get_control_store(self, repo_transport, control_files):
 
2142
        """Return the control store for this repository."""
 
2143
        raise NotImplementedError(self._get_control_store)
1456
2144
 
1457
2145
    def get_format_string(self):
1458
2146
        """Return the ASCII format string that identifies this format.
1459
 
 
1460
 
        Note that in pre format ?? repositories the format string is
 
2147
        
 
2148
        Note that in pre format ?? repositories the format string is 
1461
2149
        not permitted nor written to disk.
1462
2150
        """
1463
2151
        raise NotImplementedError(self.get_format_string)
1466
2154
        """Return the short description for this format."""
1467
2155
        raise NotImplementedError(self.get_format_description)
1468
2156
 
1469
 
    def initialize(self, controldir, shared=False):
1470
 
        """Initialize a repository of this format in controldir.
1471
 
 
1472
 
        :param controldir: The controldir to put the new repository in it.
 
2157
    def _get_revision_store(self, repo_transport, control_files):
 
2158
        """Return the revision store object for this a_bzrdir."""
 
2159
        raise NotImplementedError(self._get_revision_store)
 
2160
 
 
2161
    def _get_text_rev_store(self,
 
2162
                            transport,
 
2163
                            control_files,
 
2164
                            name,
 
2165
                            compressed=True,
 
2166
                            prefixed=False,
 
2167
                            serializer=None):
 
2168
        """Common logic for getting a revision store for a repository.
 
2169
        
 
2170
        see self._get_revision_store for the subclass-overridable method to 
 
2171
        get the store for a repository.
 
2172
        """
 
2173
        from bzrlib.store.revision.text import TextRevisionStore
 
2174
        dir_mode = control_files._dir_mode
 
2175
        file_mode = control_files._file_mode
 
2176
        text_store = TextStore(transport.clone(name),
 
2177
                              prefixed=prefixed,
 
2178
                              compressed=compressed,
 
2179
                              dir_mode=dir_mode,
 
2180
                              file_mode=file_mode)
 
2181
        _revision_store = TextRevisionStore(text_store, serializer)
 
2182
        return _revision_store
 
2183
 
 
2184
    # TODO: this shouldn't be in the base class, it's specific to things that
 
2185
    # use weaves or knits -- mbp 20070207
 
2186
    def _get_versioned_file_store(self,
 
2187
                                  name,
 
2188
                                  transport,
 
2189
                                  control_files,
 
2190
                                  prefixed=True,
 
2191
                                  versionedfile_class=None,
 
2192
                                  versionedfile_kwargs={},
 
2193
                                  escaped=False):
 
2194
        if versionedfile_class is None:
 
2195
            versionedfile_class = self._versionedfile_class
 
2196
        weave_transport = control_files._transport.clone(name)
 
2197
        dir_mode = control_files._dir_mode
 
2198
        file_mode = control_files._file_mode
 
2199
        return VersionedFileStore(weave_transport, prefixed=prefixed,
 
2200
                                  dir_mode=dir_mode,
 
2201
                                  file_mode=file_mode,
 
2202
                                  versionedfile_class=versionedfile_class,
 
2203
                                  versionedfile_kwargs=versionedfile_kwargs,
 
2204
                                  escaped=escaped)
 
2205
 
 
2206
    def initialize(self, a_bzrdir, shared=False):
 
2207
        """Initialize a repository of this format in a_bzrdir.
 
2208
 
 
2209
        :param a_bzrdir: The bzrdir to put the new repository in it.
1473
2210
        :param shared: The repository should be initialized as a sharable one.
1474
2211
        :returns: The new repository object.
1475
 
 
 
2212
        
1476
2213
        This may raise UninitializableFormat if shared repository are not
1477
 
        compatible the controldir.
 
2214
        compatible the a_bzrdir.
1478
2215
        """
1479
2216
        raise NotImplementedError(self.initialize)
1480
2217
 
1482
2219
        """Is this format supported?
1483
2220
 
1484
2221
        Supported formats must be initializable and openable.
1485
 
        Unsupported formats may not support initialization or committing or
 
2222
        Unsupported formats may not support initialization or committing or 
1486
2223
        some other features depending on the reason for not being supported.
1487
2224
        """
1488
2225
        return True
1489
2226
 
1490
 
    def is_deprecated(self):
1491
 
        """Is this format deprecated?
1492
 
 
1493
 
        Deprecated formats may trigger a user-visible warning recommending
1494
 
        the user to upgrade. They are still fully supported.
1495
 
        """
1496
 
        return False
1497
 
 
1498
 
    def network_name(self):
1499
 
        """A simple byte string uniquely identifying this format for RPC calls.
1500
 
 
1501
 
        MetaDir repository formats use their disk format string to identify the
1502
 
        repository over the wire. All in one formats such as bzr < 0.8, and
1503
 
        foreign formats like svn/git and hg should use some marker which is
1504
 
        unique and immutable.
1505
 
        """
1506
 
        raise NotImplementedError(self.network_name)
1507
 
 
1508
2227
    def check_conversion_target(self, target_format):
1509
 
        if self.rich_root_data and not target_format.rich_root_data:
1510
 
            raise errors.BadConversionTarget(
1511
 
                'Does not support rich root data.', target_format,
1512
 
                from_format=self)
1513
 
        if (self.supports_tree_reference and 
1514
 
            not getattr(target_format, 'supports_tree_reference', False)):
1515
 
            raise errors.BadConversionTarget(
1516
 
                'Does not support nested trees', target_format,
1517
 
                from_format=self)
1518
 
 
1519
 
    def open(self, controldir, _found=False):
1520
 
        """Return an instance of this format for a controldir.
1521
 
 
 
2228
        raise NotImplementedError(self.check_conversion_target)
 
2229
 
 
2230
    def open(self, a_bzrdir, _found=False):
 
2231
        """Return an instance of this format for the bzrdir a_bzrdir.
 
2232
        
1522
2233
        _found is a private parameter, do not use it.
1523
2234
        """
1524
2235
        raise NotImplementedError(self.open)
1525
2236
 
1526
 
    def _run_post_repo_init_hooks(self, repository, controldir, shared):
1527
 
        from bzrlib.controldir import ControlDir, RepoInitHookParams
1528
 
        hooks = ControlDir.hooks['post_repo_init']
1529
 
        if not hooks:
1530
 
            return
1531
 
        params = RepoInitHookParams(repository, self, controldir, shared)
1532
 
        for hook in hooks:
1533
 
            hook(params)
1534
 
 
1535
2237
 
1536
2238
class MetaDirRepositoryFormat(RepositoryFormat):
1537
2239
    """Common base class for the new repositories using the metadir layout."""
1539
2241
    rich_root_data = False
1540
2242
    supports_tree_reference = False
1541
2243
    supports_external_lookups = False
1542
 
    supports_leaving_lock = True
1543
 
    supports_nesting_repositories = True
1544
 
 
1545
 
    @property
1546
 
    def _matchingbzrdir(self):
1547
 
        matching = bzrdir.BzrDirMetaFormat1()
1548
 
        matching.repository_format = self
1549
 
        return matching
 
2244
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1550
2245
 
1551
2246
    def __init__(self):
1552
2247
        super(MetaDirRepositoryFormat, self).__init__()
1565
2260
        """Upload the initial blank content."""
1566
2261
        control_files = self._create_control_files(a_bzrdir)
1567
2262
        control_files.lock_write()
1568
 
        transport = control_files._transport
1569
 
        if shared == True:
1570
 
            utf8_files += [('shared-storage', '')]
1571
2263
        try:
1572
 
            transport.mkdir_multi(dirs, mode=a_bzrdir._get_dir_mode())
1573
 
            for (filename, content_stream) in files:
1574
 
                transport.put_file(filename, content_stream,
1575
 
                    mode=a_bzrdir._get_file_mode())
1576
 
            for (filename, content_bytes) in utf8_files:
1577
 
                transport.put_bytes_non_atomic(filename, content_bytes,
1578
 
                    mode=a_bzrdir._get_file_mode())
 
2264
            control_files._transport.mkdir_multi(dirs,
 
2265
                    mode=control_files._dir_mode)
 
2266
            for file, content in files:
 
2267
                control_files.put(file, content)
 
2268
            for file, content in utf8_files:
 
2269
                control_files.put_utf8(file, content)
 
2270
            if shared == True:
 
2271
                control_files.put_utf8('shared-storage', '')
1579
2272
        finally:
1580
2273
            control_files.unlock()
1581
2274
 
1582
 
    def network_name(self):
1583
 
        """Metadir formats have matching disk and network format strings."""
1584
 
        return self.get_format_string()
1585
 
 
1586
 
 
1587
 
# formats which have no format string are not discoverable or independently
1588
 
# creatable on disk, so are not registered in format_registry.  They're
1589
 
# all in bzrlib.repofmt.knitreponow.  When an instance of one of these is
1590
 
# needed, it's constructed directly by the ControlDir.  Non-native formats where
 
2275
 
 
2276
# formats which have no format string are not discoverable
 
2277
# and not independently creatable, so are not registered.  They're 
 
2278
# all in bzrlib.repofmt.weaverepo now.  When an instance of one of these is
 
2279
# needed, it's constructed directly by the BzrDir.  Non-native formats where
1591
2280
# the repository is not separately opened are similar.
1592
2281
 
1593
2282
format_registry.register_lazy(
 
2283
    'Bazaar-NG Repository format 7',
 
2284
    'bzrlib.repofmt.weaverepo',
 
2285
    'RepositoryFormat7'
 
2286
    )
 
2287
 
 
2288
format_registry.register_lazy(
1594
2289
    'Bazaar-NG Knit Repository Format 1',
1595
2290
    'bzrlib.repofmt.knitrepo',
1596
2291
    'RepositoryFormatKnit1',
1613
2308
# NOTE: These are experimental in 0.92. Stable in 1.0 and above
1614
2309
format_registry.register_lazy(
1615
2310
    'Bazaar pack repository format 1 (needs bzr 0.92)\n',
1616
 
    'bzrlib.repofmt.knitpack_repo',
 
2311
    'bzrlib.repofmt.pack_repo',
1617
2312
    'RepositoryFormatKnitPack1',
1618
2313
    )
1619
2314
format_registry.register_lazy(
1620
2315
    'Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n',
1621
 
    'bzrlib.repofmt.knitpack_repo',
 
2316
    'bzrlib.repofmt.pack_repo',
1622
2317
    'RepositoryFormatKnitPack3',
1623
2318
    )
1624
2319
format_registry.register_lazy(
1625
2320
    'Bazaar pack repository format 1 with rich root (needs bzr 1.0)\n',
1626
 
    'bzrlib.repofmt.knitpack_repo',
 
2321
    'bzrlib.repofmt.pack_repo',
1627
2322
    'RepositoryFormatKnitPack4',
1628
2323
    )
1629
 
format_registry.register_lazy(
1630
 
    'Bazaar RepositoryFormatKnitPack5 (bzr 1.6)\n',
1631
 
    'bzrlib.repofmt.knitpack_repo',
1632
 
    'RepositoryFormatKnitPack5',
1633
 
    )
1634
 
format_registry.register_lazy(
1635
 
    'Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n',
1636
 
    'bzrlib.repofmt.knitpack_repo',
1637
 
    'RepositoryFormatKnitPack5RichRoot',
1638
 
    )
1639
 
format_registry.register_lazy(
1640
 
    'Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n',
1641
 
    'bzrlib.repofmt.knitpack_repo',
1642
 
    'RepositoryFormatKnitPack5RichRootBroken',
1643
 
    )
1644
 
format_registry.register_lazy(
1645
 
    'Bazaar RepositoryFormatKnitPack6 (bzr 1.9)\n',
1646
 
    'bzrlib.repofmt.knitpack_repo',
1647
 
    'RepositoryFormatKnitPack6',
1648
 
    )
1649
 
format_registry.register_lazy(
1650
 
    'Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n',
1651
 
    'bzrlib.repofmt.knitpack_repo',
1652
 
    'RepositoryFormatKnitPack6RichRoot',
1653
 
    )
1654
 
format_registry.register_lazy(
1655
 
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
1656
 
    'bzrlib.repofmt.groupcompress_repo',
1657
 
    'RepositoryFormat2a',
1658
 
    )
1659
 
 
1660
 
# Development formats.
1661
 
# Check their docstrings to see if/when they are obsolete.
1662
 
format_registry.register_lazy(
1663
 
    ("Bazaar development format 2 with subtree support "
1664
 
        "(needs bzr.dev from before 1.8)\n"),
1665
 
    'bzrlib.repofmt.knitpack_repo',
1666
 
    'RepositoryFormatPackDevelopment2Subtree',
1667
 
    )
1668
 
format_registry.register_lazy(
1669
 
    'Bazaar development format 8\n',
1670
 
    'bzrlib.repofmt.groupcompress_repo',
1671
 
    'RepositoryFormat2aSubtree',
1672
 
    )
 
2324
# Development formats. 
 
2325
# 1.2->1.3
 
2326
# development 0 - stub to introduce development versioning scheme.
 
2327
format_registry.register_lazy(
 
2328
    "Bazaar development format 0 (needs bzr.dev from before 1.3)\n",
 
2329
    'bzrlib.repofmt.pack_repo',
 
2330
    'RepositoryFormatPackDevelopment0',
 
2331
    )
 
2332
format_registry.register_lazy(
 
2333
    ("Bazaar development format 0 with subtree support "
 
2334
        "(needs bzr.dev from before 1.3)\n"),
 
2335
    'bzrlib.repofmt.pack_repo',
 
2336
    'RepositoryFormatPackDevelopment0Subtree',
 
2337
    )
 
2338
# 1.3->1.4 go below here
1673
2339
 
1674
2340
 
1675
2341
class InterRepository(InterObject):
1676
2342
    """This class represents operations taking place between two repositories.
1677
2343
 
1678
2344
    Its instances have methods like copy_content and fetch, and contain
1679
 
    references to the source and target repositories these operations can be
 
2345
    references to the source and target repositories these operations can be 
1680
2346
    carried out on.
1681
2347
 
1682
2348
    Often we will provide convenience methods on 'repository' which carry out
1687
2353
    _optimisers = []
1688
2354
    """The available optimised InterRepository types."""
1689
2355
 
1690
 
    @needs_write_lock
1691
2356
    def copy_content(self, revision_id=None):
1692
 
        """Make a complete copy of the content in self into destination.
1693
 
 
1694
 
        This is a destructive operation! Do not use it on existing
1695
 
        repositories.
1696
 
 
1697
 
        :param revision_id: Only copy the content needed to construct
1698
 
                            revision_id and its parents.
1699
 
        """
1700
 
        try:
1701
 
            self.target.set_make_working_trees(self.source.make_working_trees())
1702
 
        except NotImplementedError:
1703
 
            pass
1704
 
        self.target.fetch(self.source, revision_id=revision_id)
1705
 
 
1706
 
    @needs_write_lock
1707
 
    def fetch(self, revision_id=None, find_ghosts=False,
1708
 
            fetch_spec=None):
 
2357
        raise NotImplementedError(self.copy_content)
 
2358
 
 
2359
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1709
2360
        """Fetch the content required to construct revision_id.
1710
2361
 
1711
2362
        The content is copied from self.source to self.target.
1712
2363
 
1713
2364
        :param revision_id: if None all content is copied, if NULL_REVISION no
1714
2365
                            content is copied.
1715
 
        :return: None.
 
2366
        :param pb: optional progress bar to use for progress reports. If not
 
2367
                   provided a default one will be created.
 
2368
 
 
2369
        Returns the copied revision count and the failed revisions in a tuple:
 
2370
        (copied, failures).
1716
2371
        """
1717
2372
        raise NotImplementedError(self.fetch)
1718
2373
 
1719
 
    @needs_read_lock
1720
 
    def search_missing_revision_ids(self,
1721
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1722
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
1723
 
            limit=None):
1724
 
        """Return the revision ids that source has that target does not.
1725
 
 
1726
 
        :param revision_id: only return revision ids included by this
1727
 
            revision_id.
1728
 
        :param revision_ids: return revision ids included by these
1729
 
            revision_ids.  NoSuchRevision will be raised if any of these
1730
 
            revisions are not present.
1731
 
        :param if_present_ids: like revision_ids, but will not cause
1732
 
            NoSuchRevision if any of these are absent, instead they will simply
1733
 
            not be in the result.  This is useful for e.g. finding revisions
1734
 
            to fetch for tags, which may reference absent revisions.
1735
 
        :param find_ghosts: If True find missing revisions in deep history
1736
 
            rather than just finding the surface difference.
1737
 
        :param limit: Maximum number of revisions to return, topologically
1738
 
            ordered
 
2374
    def _walk_to_common_revisions(self, revision_ids):
 
2375
        """Walk out from revision_ids in source to revisions target has.
 
2376
 
 
2377
        :param revision_ids: The start point for the search.
 
2378
        :return: A set of revision ids.
 
2379
        """
 
2380
        graph = self.source.get_graph()
 
2381
        missing_revs = set()
 
2382
        # ensure we don't pay silly lookup costs.
 
2383
        revision_ids = frozenset(revision_ids)
 
2384
        searcher = graph._make_breadth_first_searcher(revision_ids)
 
2385
        null_set = frozenset([_mod_revision.NULL_REVISION])
 
2386
        while True:
 
2387
            try:
 
2388
                next_revs, ghosts = searcher.next_with_ghosts()
 
2389
            except StopIteration:
 
2390
                break
 
2391
            if revision_ids.intersection(ghosts):
 
2392
                absent_ids = set(revision_ids.intersection(ghosts))
 
2393
                # If all absent_ids are present in target, no error is needed.
 
2394
                absent_ids.difference_update(
 
2395
                    self.target.has_revisions(absent_ids))
 
2396
                if absent_ids:
 
2397
                    raise errors.NoSuchRevision(self.source, absent_ids.pop())
 
2398
            # we don't care about other ghosts as we can't fetch them and
 
2399
            # haven't been asked to.
 
2400
            next_revs = set(next_revs)
 
2401
            # we always have NULL_REVISION present.
 
2402
            have_revs = self.target.has_revisions(next_revs).union(null_set)
 
2403
            missing_revs.update(next_revs - have_revs)
 
2404
            searcher.stop_searching_any(have_revs)
 
2405
        return searcher.get_result()
 
2406
   
 
2407
    @deprecated_method(symbol_versioning.one_two)
 
2408
    @needs_read_lock
 
2409
    def missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
2410
        """Return the revision ids that source has that target does not.
 
2411
        
 
2412
        These are returned in topological order.
 
2413
 
 
2414
        :param revision_id: only return revision ids included by this
 
2415
                            revision_id.
 
2416
        :param find_ghosts: If True find missing revisions in deep history
 
2417
            rather than just finding the surface difference.
 
2418
        """
 
2419
        return list(self.search_missing_revision_ids(
 
2420
            revision_id, find_ghosts).get_keys())
 
2421
 
 
2422
    @needs_read_lock
 
2423
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
2424
        """Return the revision ids that source has that target does not.
 
2425
        
 
2426
        :param revision_id: only return revision ids included by this
 
2427
                            revision_id.
 
2428
        :param find_ghosts: If True find missing revisions in deep history
 
2429
            rather than just finding the surface difference.
1739
2430
        :return: A bzrlib.graph.SearchResult.
1740
2431
        """
1741
 
        raise NotImplementedError(self.search_missing_revision_ids)
 
2432
        # stop searching at found target revisions.
 
2433
        if not find_ghosts and revision_id is not None:
 
2434
            return self._walk_to_common_revisions([revision_id])
 
2435
        # generic, possibly worst case, slow code path.
 
2436
        target_ids = set(self.target.all_revision_ids())
 
2437
        if revision_id is not None:
 
2438
            source_ids = self.source.get_ancestry(revision_id)
 
2439
            assert source_ids[0] is None
 
2440
            source_ids.pop(0)
 
2441
        else:
 
2442
            source_ids = self.source.all_revision_ids()
 
2443
        result_set = set(source_ids).difference(target_ids)
 
2444
        return self.source.revision_ids_to_search_result(result_set)
1742
2445
 
1743
2446
    @staticmethod
1744
2447
    def _same_model(source, target):
1745
 
        """True if source and target have the same data representation.
1746
 
 
1747
 
        Note: this is always called on the base class; overriding it in a
1748
 
        subclass will have no effect.
1749
 
        """
1750
 
        try:
1751
 
            InterRepository._assert_same_model(source, target)
1752
 
            return True
1753
 
        except errors.IncompatibleRepositories, e:
 
2448
        """True if source and target have the same data representation."""
 
2449
        if source.supports_rich_root() != target.supports_rich_root():
1754
2450
            return False
1755
 
 
1756
 
    @staticmethod
1757
 
    def _assert_same_model(source, target):
1758
 
        """Raise an exception if two repositories do not use the same model.
1759
 
        """
1760
 
        if source.supports_rich_root() != target.supports_rich_root():
1761
 
            raise errors.IncompatibleRepositories(source, target,
1762
 
                "different rich-root support")
1763
2451
        if source._serializer != target._serializer:
1764
 
            raise errors.IncompatibleRepositories(source, target,
1765
 
                "different serializers")
 
2452
            return False
 
2453
        return True
 
2454
 
 
2455
 
 
2456
class InterSameDataRepository(InterRepository):
 
2457
    """Code for converting between repositories that represent the same data.
 
2458
    
 
2459
    Data format and model must match for this to work.
 
2460
    """
 
2461
 
 
2462
    @classmethod
 
2463
    def _get_repo_format_to_test(self):
 
2464
        """Repository format for testing with.
 
2465
        
 
2466
        InterSameData can pull from subtree to subtree and from non-subtree to
 
2467
        non-subtree, so we test this with the richest repository format.
 
2468
        """
 
2469
        from bzrlib.repofmt import knitrepo
 
2470
        return knitrepo.RepositoryFormatKnit3()
 
2471
 
 
2472
    @staticmethod
 
2473
    def is_compatible(source, target):
 
2474
        return InterRepository._same_model(source, target)
 
2475
 
 
2476
    @needs_write_lock
 
2477
    def copy_content(self, revision_id=None):
 
2478
        """Make a complete copy of the content in self into destination.
 
2479
 
 
2480
        This copies both the repository's revision data, and configuration information
 
2481
        such as the make_working_trees setting.
 
2482
        
 
2483
        This is a destructive operation! Do not use it on existing 
 
2484
        repositories.
 
2485
 
 
2486
        :param revision_id: Only copy the content needed to construct
 
2487
                            revision_id and its parents.
 
2488
        """
 
2489
        try:
 
2490
            self.target.set_make_working_trees(self.source.make_working_trees())
 
2491
        except NotImplementedError:
 
2492
            pass
 
2493
        # but don't bother fetching if we have the needed data now.
 
2494
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
2495
            self.target.has_revision(revision_id)):
 
2496
            return
 
2497
        self.target.fetch(self.source, revision_id=revision_id)
 
2498
 
 
2499
    @needs_write_lock
 
2500
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2501
        """See InterRepository.fetch()."""
 
2502
        from bzrlib.fetch import GenericRepoFetcher
 
2503
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2504
               self.source, self.source._format, self.target,
 
2505
               self.target._format)
 
2506
        f = GenericRepoFetcher(to_repository=self.target,
 
2507
                               from_repository=self.source,
 
2508
                               last_revision=revision_id,
 
2509
                               pb=pb, find_ghosts=find_ghosts)
 
2510
        return f.count_copied, f.failed_revisions
 
2511
 
 
2512
 
 
2513
class InterWeaveRepo(InterSameDataRepository):
 
2514
    """Optimised code paths between Weave based repositories.
 
2515
    
 
2516
    This should be in bzrlib/repofmt/weaverepo.py but we have not yet
 
2517
    implemented lazy inter-object optimisation.
 
2518
    """
 
2519
 
 
2520
    @classmethod
 
2521
    def _get_repo_format_to_test(self):
 
2522
        from bzrlib.repofmt import weaverepo
 
2523
        return weaverepo.RepositoryFormat7()
 
2524
 
 
2525
    @staticmethod
 
2526
    def is_compatible(source, target):
 
2527
        """Be compatible with known Weave formats.
 
2528
        
 
2529
        We don't test for the stores being of specific types because that
 
2530
        could lead to confusing results, and there is no need to be 
 
2531
        overly general.
 
2532
        """
 
2533
        from bzrlib.repofmt.weaverepo import (
 
2534
                RepositoryFormat5,
 
2535
                RepositoryFormat6,
 
2536
                RepositoryFormat7,
 
2537
                )
 
2538
        try:
 
2539
            return (isinstance(source._format, (RepositoryFormat5,
 
2540
                                                RepositoryFormat6,
 
2541
                                                RepositoryFormat7)) and
 
2542
                    isinstance(target._format, (RepositoryFormat5,
 
2543
                                                RepositoryFormat6,
 
2544
                                                RepositoryFormat7)))
 
2545
        except AttributeError:
 
2546
            return False
 
2547
    
 
2548
    @needs_write_lock
 
2549
    def copy_content(self, revision_id=None):
 
2550
        """See InterRepository.copy_content()."""
 
2551
        # weave specific optimised path:
 
2552
        try:
 
2553
            self.target.set_make_working_trees(self.source.make_working_trees())
 
2554
        except NotImplementedError:
 
2555
            pass
 
2556
        # FIXME do not peek!
 
2557
        if self.source.control_files._transport.listable():
 
2558
            pb = ui.ui_factory.nested_progress_bar()
 
2559
            try:
 
2560
                self.target.weave_store.copy_all_ids(
 
2561
                    self.source.weave_store,
 
2562
                    pb=pb,
 
2563
                    from_transaction=self.source.get_transaction(),
 
2564
                    to_transaction=self.target.get_transaction())
 
2565
                pb.update('copying inventory', 0, 1)
 
2566
                self.target.control_weaves.copy_multi(
 
2567
                    self.source.control_weaves, ['inventory'],
 
2568
                    from_transaction=self.source.get_transaction(),
 
2569
                    to_transaction=self.target.get_transaction())
 
2570
                self.target._revision_store.text_store.copy_all_ids(
 
2571
                    self.source._revision_store.text_store,
 
2572
                    pb=pb)
 
2573
            finally:
 
2574
                pb.finished()
 
2575
        else:
 
2576
            self.target.fetch(self.source, revision_id=revision_id)
 
2577
 
 
2578
    @needs_write_lock
 
2579
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2580
        """See InterRepository.fetch()."""
 
2581
        from bzrlib.fetch import GenericRepoFetcher
 
2582
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2583
               self.source, self.source._format, self.target, self.target._format)
 
2584
        f = GenericRepoFetcher(to_repository=self.target,
 
2585
                               from_repository=self.source,
 
2586
                               last_revision=revision_id,
 
2587
                               pb=pb, find_ghosts=find_ghosts)
 
2588
        return f.count_copied, f.failed_revisions
 
2589
 
 
2590
    @needs_read_lock
 
2591
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
2592
        """See InterRepository.missing_revision_ids()."""
 
2593
        # we want all revisions to satisfy revision_id in source.
 
2594
        # but we don't want to stat every file here and there.
 
2595
        # we want then, all revisions other needs to satisfy revision_id 
 
2596
        # checked, but not those that we have locally.
 
2597
        # so the first thing is to get a subset of the revisions to 
 
2598
        # satisfy revision_id in source, and then eliminate those that
 
2599
        # we do already have. 
 
2600
        # this is slow on high latency connection to self, but as as this
 
2601
        # disk format scales terribly for push anyway due to rewriting 
 
2602
        # inventory.weave, this is considered acceptable.
 
2603
        # - RBC 20060209
 
2604
        if revision_id is not None:
 
2605
            source_ids = self.source.get_ancestry(revision_id)
 
2606
            assert source_ids[0] is None
 
2607
            source_ids.pop(0)
 
2608
        else:
 
2609
            source_ids = self.source._all_possible_ids()
 
2610
        source_ids_set = set(source_ids)
 
2611
        # source_ids is the worst possible case we may need to pull.
 
2612
        # now we want to filter source_ids against what we actually
 
2613
        # have in target, but don't try to check for existence where we know
 
2614
        # we do not have a revision as that would be pointless.
 
2615
        target_ids = set(self.target._all_possible_ids())
 
2616
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
2617
        actually_present_revisions = set(
 
2618
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
2619
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
2620
        if revision_id is not None:
 
2621
            # we used get_ancestry to determine source_ids then we are assured all
 
2622
            # revisions referenced are present as they are installed in topological order.
 
2623
            # and the tip revision was validated by get_ancestry.
 
2624
            result_set = required_revisions
 
2625
        else:
 
2626
            # if we just grabbed the possibly available ids, then 
 
2627
            # we only have an estimate of whats available and need to validate
 
2628
            # that against the revision records.
 
2629
            result_set = set(
 
2630
                self.source._eliminate_revisions_not_present(required_revisions))
 
2631
        return self.source.revision_ids_to_search_result(result_set)
 
2632
 
 
2633
 
 
2634
class InterKnitRepo(InterSameDataRepository):
 
2635
    """Optimised code paths between Knit based repositories."""
 
2636
 
 
2637
    @classmethod
 
2638
    def _get_repo_format_to_test(self):
 
2639
        from bzrlib.repofmt import knitrepo
 
2640
        return knitrepo.RepositoryFormatKnit1()
 
2641
 
 
2642
    @staticmethod
 
2643
    def is_compatible(source, target):
 
2644
        """Be compatible with known Knit formats.
 
2645
        
 
2646
        We don't test for the stores being of specific types because that
 
2647
        could lead to confusing results, and there is no need to be 
 
2648
        overly general.
 
2649
        """
 
2650
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
 
2651
        try:
 
2652
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
 
2653
                isinstance(target._format, RepositoryFormatKnit))
 
2654
        except AttributeError:
 
2655
            return False
 
2656
        return are_knits and InterRepository._same_model(source, target)
 
2657
 
 
2658
    @needs_write_lock
 
2659
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2660
        """See InterRepository.fetch()."""
 
2661
        from bzrlib.fetch import KnitRepoFetcher
 
2662
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2663
               self.source, self.source._format, self.target, self.target._format)
 
2664
        f = KnitRepoFetcher(to_repository=self.target,
 
2665
                            from_repository=self.source,
 
2666
                            last_revision=revision_id,
 
2667
                            pb=pb, find_ghosts=find_ghosts)
 
2668
        return f.count_copied, f.failed_revisions
 
2669
 
 
2670
    @needs_read_lock
 
2671
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
2672
        """See InterRepository.missing_revision_ids()."""
 
2673
        if revision_id is not None:
 
2674
            source_ids = self.source.get_ancestry(revision_id)
 
2675
            assert source_ids[0] is None
 
2676
            source_ids.pop(0)
 
2677
        else:
 
2678
            source_ids = self.source.all_revision_ids()
 
2679
        source_ids_set = set(source_ids)
 
2680
        # source_ids is the worst possible case we may need to pull.
 
2681
        # now we want to filter source_ids against what we actually
 
2682
        # have in target, but don't try to check for existence where we know
 
2683
        # we do not have a revision as that would be pointless.
 
2684
        target_ids = set(self.target.all_revision_ids())
 
2685
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
2686
        actually_present_revisions = set(
 
2687
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
2688
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
2689
        if revision_id is not None:
 
2690
            # we used get_ancestry to determine source_ids then we are assured all
 
2691
            # revisions referenced are present as they are installed in topological order.
 
2692
            # and the tip revision was validated by get_ancestry.
 
2693
            result_set = required_revisions
 
2694
        else:
 
2695
            # if we just grabbed the possibly available ids, then 
 
2696
            # we only have an estimate of whats available and need to validate
 
2697
            # that against the revision records.
 
2698
            result_set = set(
 
2699
                self.source._eliminate_revisions_not_present(required_revisions))
 
2700
        return self.source.revision_ids_to_search_result(result_set)
 
2701
 
 
2702
 
 
2703
class InterPackRepo(InterSameDataRepository):
 
2704
    """Optimised code paths between Pack based repositories."""
 
2705
 
 
2706
    @classmethod
 
2707
    def _get_repo_format_to_test(self):
 
2708
        from bzrlib.repofmt import pack_repo
 
2709
        return pack_repo.RepositoryFormatKnitPack1()
 
2710
 
 
2711
    @staticmethod
 
2712
    def is_compatible(source, target):
 
2713
        """Be compatible with known Pack formats.
 
2714
        
 
2715
        We don't test for the stores being of specific types because that
 
2716
        could lead to confusing results, and there is no need to be 
 
2717
        overly general.
 
2718
        """
 
2719
        from bzrlib.repofmt.pack_repo import RepositoryFormatPack
 
2720
        try:
 
2721
            are_packs = (isinstance(source._format, RepositoryFormatPack) and
 
2722
                isinstance(target._format, RepositoryFormatPack))
 
2723
        except AttributeError:
 
2724
            return False
 
2725
        return are_packs and InterRepository._same_model(source, target)
 
2726
 
 
2727
    @needs_write_lock
 
2728
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2729
        """See InterRepository.fetch()."""
 
2730
        from bzrlib.repofmt.pack_repo import Packer
 
2731
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2732
               self.source, self.source._format, self.target, self.target._format)
 
2733
        self.count_copied = 0
 
2734
        if revision_id is None:
 
2735
            # TODO:
 
2736
            # everything to do - use pack logic
 
2737
            # to fetch from all packs to one without
 
2738
            # inventory parsing etc, IFF nothing to be copied is in the target.
 
2739
            # till then:
 
2740
            revision_ids = self.source.all_revision_ids()
 
2741
            # implementing the TODO will involve:
 
2742
            # - detecting when all of a pack is selected
 
2743
            # - avoiding as much as possible pre-selection, so the
 
2744
            # more-core routines such as create_pack_from_packs can filter in
 
2745
            # a just-in-time fashion. (though having a HEADS list on a
 
2746
            # repository might make this a lot easier, because we could
 
2747
            # sensibly detect 'new revisions' without doing a full index scan.
 
2748
        elif _mod_revision.is_null(revision_id):
 
2749
            # nothing to do:
 
2750
            return (0, [])
 
2751
        else:
 
2752
            try:
 
2753
                revision_ids = self.search_missing_revision_ids(revision_id,
 
2754
                    find_ghosts=find_ghosts).get_keys()
 
2755
            except errors.NoSuchRevision:
 
2756
                raise errors.InstallFailed([revision_id])
 
2757
        packs = self.source._pack_collection.all_packs()
 
2758
        pack = Packer(self.target._pack_collection, packs, '.fetch',
 
2759
            revision_ids).pack()
 
2760
        if pack is not None:
 
2761
            self.target._pack_collection._save_pack_names()
 
2762
            # Trigger an autopack. This may duplicate effort as we've just done
 
2763
            # a pack creation, but for now it is simpler to think about as
 
2764
            # 'upload data, then repack if needed'.
 
2765
            self.target._pack_collection.autopack()
 
2766
            return (pack.get_revision_count(), [])
 
2767
        else:
 
2768
            return (0, [])
 
2769
 
 
2770
    @needs_read_lock
 
2771
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
 
2772
        """See InterRepository.missing_revision_ids().
 
2773
        
 
2774
        :param find_ghosts: Find ghosts throughout the ancestry of
 
2775
            revision_id.
 
2776
        """
 
2777
        if not find_ghosts and revision_id is not None:
 
2778
            return self._walk_to_common_revisions([revision_id])
 
2779
        elif revision_id is not None:
 
2780
            source_ids = self.source.get_ancestry(revision_id)
 
2781
            assert source_ids[0] is None
 
2782
            source_ids.pop(0)
 
2783
        else:
 
2784
            source_ids = self.source.all_revision_ids()
 
2785
        # source_ids is the worst possible case we may need to pull.
 
2786
        # now we want to filter source_ids against what we actually
 
2787
        # have in target, but don't try to check for existence where we know
 
2788
        # we do not have a revision as that would be pointless.
 
2789
        target_ids = set(self.target.all_revision_ids())
 
2790
        result_set = set(source_ids).difference(target_ids)
 
2791
        return self.source.revision_ids_to_search_result(result_set)
 
2792
 
 
2793
 
 
2794
class InterModel1and2(InterRepository):
 
2795
 
 
2796
    @classmethod
 
2797
    def _get_repo_format_to_test(self):
 
2798
        return None
 
2799
 
 
2800
    @staticmethod
 
2801
    def is_compatible(source, target):
 
2802
        if not source.supports_rich_root() and target.supports_rich_root():
 
2803
            return True
 
2804
        else:
 
2805
            return False
 
2806
 
 
2807
    @needs_write_lock
 
2808
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2809
        """See InterRepository.fetch()."""
 
2810
        from bzrlib.fetch import Model1toKnit2Fetcher
 
2811
        f = Model1toKnit2Fetcher(to_repository=self.target,
 
2812
                                 from_repository=self.source,
 
2813
                                 last_revision=revision_id,
 
2814
                                 pb=pb, find_ghosts=find_ghosts)
 
2815
        return f.count_copied, f.failed_revisions
 
2816
 
 
2817
    @needs_write_lock
 
2818
    def copy_content(self, revision_id=None):
 
2819
        """Make a complete copy of the content in self into destination.
 
2820
        
 
2821
        This is a destructive operation! Do not use it on existing 
 
2822
        repositories.
 
2823
 
 
2824
        :param revision_id: Only copy the content needed to construct
 
2825
                            revision_id and its parents.
 
2826
        """
 
2827
        try:
 
2828
            self.target.set_make_working_trees(self.source.make_working_trees())
 
2829
        except NotImplementedError:
 
2830
            pass
 
2831
        # but don't bother fetching if we have the needed data now.
 
2832
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
2833
            self.target.has_revision(revision_id)):
 
2834
            return
 
2835
        self.target.fetch(self.source, revision_id=revision_id)
 
2836
 
 
2837
 
 
2838
class InterKnit1and2(InterKnitRepo):
 
2839
 
 
2840
    @classmethod
 
2841
    def _get_repo_format_to_test(self):
 
2842
        return None
 
2843
 
 
2844
    @staticmethod
 
2845
    def is_compatible(source, target):
 
2846
        """Be compatible with Knit1 source and Knit3 target"""
 
2847
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit3
 
2848
        try:
 
2849
            from bzrlib.repofmt.knitrepo import (RepositoryFormatKnit1,
 
2850
                RepositoryFormatKnit3)
 
2851
            from bzrlib.repofmt.pack_repo import (
 
2852
                RepositoryFormatKnitPack1,
 
2853
                RepositoryFormatKnitPack3,
 
2854
                RepositoryFormatPackDevelopment0,
 
2855
                RepositoryFormatPackDevelopment0Subtree,
 
2856
                )
 
2857
            nosubtrees = (
 
2858
                RepositoryFormatKnit1,
 
2859
                RepositoryFormatKnitPack1,
 
2860
                RepositoryFormatPackDevelopment0,
 
2861
                )
 
2862
            subtrees = (
 
2863
                RepositoryFormatKnit3,
 
2864
                RepositoryFormatKnitPack3,
 
2865
                RepositoryFormatPackDevelopment0Subtree,
 
2866
                )
 
2867
            return (isinstance(source._format, nosubtrees) and
 
2868
                isinstance(target._format, subtrees))
 
2869
        except AttributeError:
 
2870
            return False
 
2871
 
 
2872
    @needs_write_lock
 
2873
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2874
        """See InterRepository.fetch()."""
 
2875
        from bzrlib.fetch import Knit1to2Fetcher
 
2876
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2877
               self.source, self.source._format, self.target, 
 
2878
               self.target._format)
 
2879
        f = Knit1to2Fetcher(to_repository=self.target,
 
2880
                            from_repository=self.source,
 
2881
                            last_revision=revision_id,
 
2882
                            pb=pb, find_ghosts=find_ghosts)
 
2883
        return f.count_copied, f.failed_revisions
 
2884
 
 
2885
 
 
2886
class InterDifferingSerializer(InterKnitRepo):
 
2887
 
 
2888
    @classmethod
 
2889
    def _get_repo_format_to_test(self):
 
2890
        return None
 
2891
 
 
2892
    @staticmethod
 
2893
    def is_compatible(source, target):
 
2894
        """Be compatible with Knit2 source and Knit3 target"""
 
2895
        if source.supports_rich_root() != target.supports_rich_root():
 
2896
            return False
 
2897
        # Ideally, we'd support fetching if the source had no tree references
 
2898
        # even if it supported them...
 
2899
        if (getattr(source, '_format.supports_tree_reference', False) and
 
2900
            not getattr(target, '_format.supports_tree_reference', False)):
 
2901
            return False
 
2902
        return True
 
2903
 
 
2904
    @needs_write_lock
 
2905
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2906
        """See InterRepository.fetch()."""
 
2907
        revision_ids = self.target.search_missing_revision_ids(self.source,
 
2908
            revision_id, find_ghosts=find_ghosts).get_keys()
 
2909
        revision_ids = tsort.topo_sort(
 
2910
            self.source.get_graph().get_parent_map(revision_ids))
 
2911
        def revisions_iterator():
 
2912
            for current_revision_id in revision_ids:
 
2913
                revision = self.source.get_revision(current_revision_id)
 
2914
                tree = self.source.revision_tree(current_revision_id)
 
2915
                try:
 
2916
                    signature = self.source.get_signature_text(
 
2917
                        current_revision_id)
 
2918
                except errors.NoSuchRevision:
 
2919
                    signature = None
 
2920
                yield revision, tree, signature
 
2921
        if pb is None:
 
2922
            my_pb = ui.ui_factory.nested_progress_bar()
 
2923
            pb = my_pb
 
2924
        else:
 
2925
            my_pb = None
 
2926
        try:
 
2927
            install_revisions(self.target, revisions_iterator(),
 
2928
                              len(revision_ids), pb)
 
2929
        finally:
 
2930
            if my_pb is not None:
 
2931
                my_pb.finished()
 
2932
        return len(revision_ids), 0
 
2933
 
 
2934
 
 
2935
class InterRemoteToOther(InterRepository):
 
2936
 
 
2937
    def __init__(self, source, target):
 
2938
        InterRepository.__init__(self, source, target)
 
2939
        self._real_inter = None
 
2940
 
 
2941
    @staticmethod
 
2942
    def is_compatible(source, target):
 
2943
        if not isinstance(source, remote.RemoteRepository):
 
2944
            return False
 
2945
        # Is source's model compatible with target's model?
 
2946
        source._ensure_real()
 
2947
        real_source = source._real_repository
 
2948
        assert not isinstance(real_source, remote.RemoteRepository), (
 
2949
            "We don't support remote repos backed by remote repos yet.")
 
2950
        return InterRepository._same_model(real_source, target)
 
2951
 
 
2952
    @needs_write_lock
 
2953
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2954
        """See InterRepository.fetch()."""
 
2955
        from bzrlib.fetch import RemoteToOtherFetcher
 
2956
        mutter("Using fetch logic to copy between %s(remote) and %s(%s)",
 
2957
               self.source, self.target, self.target._format)
 
2958
        # TODO: jam 20070210 This should be an assert, not a translate
 
2959
        revision_id = osutils.safe_revision_id(revision_id)
 
2960
        f = RemoteToOtherFetcher(to_repository=self.target,
 
2961
                                 from_repository=self.source,
 
2962
                                 last_revision=revision_id,
 
2963
                                 pb=pb, find_ghosts=find_ghosts)
 
2964
        return f.count_copied, f.failed_revisions
 
2965
 
 
2966
    @classmethod
 
2967
    def _get_repo_format_to_test(self):
 
2968
        return None
 
2969
 
 
2970
 
 
2971
class InterOtherToRemote(InterRepository):
 
2972
 
 
2973
    def __init__(self, source, target):
 
2974
        InterRepository.__init__(self, source, target)
 
2975
        self._real_inter = None
 
2976
 
 
2977
    @staticmethod
 
2978
    def is_compatible(source, target):
 
2979
        if isinstance(target, remote.RemoteRepository):
 
2980
            return True
 
2981
        return False
 
2982
 
 
2983
    def _ensure_real_inter(self):
 
2984
        if self._real_inter is None:
 
2985
            self.target._ensure_real()
 
2986
            real_target = self.target._real_repository
 
2987
            self._real_inter = InterRepository.get(self.source, real_target)
 
2988
    
 
2989
    def copy_content(self, revision_id=None):
 
2990
        self._ensure_real_inter()
 
2991
        self._real_inter.copy_content(revision_id=revision_id)
 
2992
 
 
2993
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2994
        self._ensure_real_inter()
 
2995
        self._real_inter.fetch(revision_id=revision_id, pb=pb,
 
2996
            find_ghosts=find_ghosts)
 
2997
 
 
2998
    @classmethod
 
2999
    def _get_repo_format_to_test(self):
 
3000
        return None
 
3001
 
 
3002
 
 
3003
InterRepository.register_optimiser(InterDifferingSerializer)
 
3004
InterRepository.register_optimiser(InterSameDataRepository)
 
3005
InterRepository.register_optimiser(InterWeaveRepo)
 
3006
InterRepository.register_optimiser(InterKnitRepo)
 
3007
InterRepository.register_optimiser(InterModel1and2)
 
3008
InterRepository.register_optimiser(InterKnit1and2)
 
3009
InterRepository.register_optimiser(InterPackRepo)
 
3010
InterRepository.register_optimiser(InterRemoteToOther)
 
3011
InterRepository.register_optimiser(InterOtherToRemote)
1766
3012
 
1767
3013
 
1768
3014
class CopyConverter(object):
1769
3015
    """A repository conversion tool which just performs a copy of the content.
1770
 
 
 
3016
    
1771
3017
    This is slow but quite reliable.
1772
3018
    """
1773
3019
 
1777
3023
        :param target_format: The format the resulting repository should be.
1778
3024
        """
1779
3025
        self.target_format = target_format
1780
 
 
 
3026
        
1781
3027
    def convert(self, repo, pb):
1782
3028
        """Perform the conversion of to_convert, giving feedback via pb.
1783
3029
 
1784
3030
        :param to_convert: The disk object to convert.
1785
3031
        :param pb: a progress bar to use for progress information.
1786
3032
        """
1787
 
        pb = ui.ui_factory.nested_progress_bar()
 
3033
        self.pb = pb
1788
3034
        self.count = 0
1789
3035
        self.total = 4
1790
3036
        # this is only useful with metadir layouts - separated repo content.
1791
3037
        # trigger an assertion if not such
1792
3038
        repo._format.get_format_string()
1793
3039
        self.repo_dir = repo.bzrdir
1794
 
        pb.update(gettext('Moving repository to repository.backup'))
 
3040
        self.step('Moving repository to repository.backup')
1795
3041
        self.repo_dir.transport.move('repository', 'repository.backup')
1796
3042
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
1797
3043
        repo._format.check_conversion_target(self.target_format)
1798
3044
        self.source_repo = repo._format.open(self.repo_dir,
1799
3045
            _found=True,
1800
3046
            _override_transport=backup_transport)
1801
 
        pb.update(gettext('Creating new repository'))
 
3047
        self.step('Creating new repository')
1802
3048
        converted = self.target_format.initialize(self.repo_dir,
1803
3049
                                                  self.source_repo.is_shared())
1804
3050
        converted.lock_write()
1805
3051
        try:
1806
 
            pb.update(gettext('Copying content'))
 
3052
            self.step('Copying content into repository.')
1807
3053
            self.source_repo.copy_content_into(converted)
1808
3054
        finally:
1809
3055
            converted.unlock()
1810
 
        pb.update(gettext('Deleting old repository content'))
 
3056
        self.step('Deleting old repository content.')
1811
3057
        self.repo_dir.transport.delete_tree('repository.backup')
1812
 
        ui.ui_factory.note(gettext('repository converted'))
1813
 
        pb.finished()
1814
 
 
1815
 
 
1816
 
def _strip_NULL_ghosts(revision_graph):
1817
 
    """Also don't use this. more compatibility code for unmigrated clients."""
1818
 
    # Filter ghosts, and null:
1819
 
    if _mod_revision.NULL_REVISION in revision_graph:
1820
 
        del revision_graph[_mod_revision.NULL_REVISION]
1821
 
    for key, parents in revision_graph.items():
1822
 
        revision_graph[key] = tuple(parent for parent in parents if parent
1823
 
            in revision_graph)
1824
 
    return revision_graph
1825
 
 
1826
 
 
1827
 
def _iter_for_revno(repo, partial_history_cache, stop_index=None,
1828
 
                    stop_revision=None):
1829
 
    """Extend the partial history to include a given index
1830
 
 
1831
 
    If a stop_index is supplied, stop when that index has been reached.
1832
 
    If a stop_revision is supplied, stop when that revision is
1833
 
    encountered.  Otherwise, stop when the beginning of history is
1834
 
    reached.
1835
 
 
1836
 
    :param stop_index: The index which should be present.  When it is
1837
 
        present, history extension will stop.
1838
 
    :param stop_revision: The revision id which should be present.  When
1839
 
        it is encountered, history extension will stop.
1840
 
    """
1841
 
    start_revision = partial_history_cache[-1]
1842
 
    graph = repo.get_graph()
1843
 
    iterator = graph.iter_lefthand_ancestry(start_revision,
1844
 
        (_mod_revision.NULL_REVISION,))
 
3058
        self.pb.note('repository converted')
 
3059
 
 
3060
    def step(self, message):
 
3061
        """Update the pb by a step."""
 
3062
        self.count +=1
 
3063
        self.pb.update(message, self.count, self.total)
 
3064
 
 
3065
 
 
3066
_unescape_map = {
 
3067
    'apos':"'",
 
3068
    'quot':'"',
 
3069
    'amp':'&',
 
3070
    'lt':'<',
 
3071
    'gt':'>'
 
3072
}
 
3073
 
 
3074
 
 
3075
def _unescaper(match, _map=_unescape_map):
 
3076
    code = match.group(1)
1845
3077
    try:
1846
 
        # skip the last revision in the list
1847
 
        iterator.next()
1848
 
        while True:
1849
 
            if (stop_index is not None and
1850
 
                len(partial_history_cache) > stop_index):
1851
 
                break
1852
 
            if partial_history_cache[-1] == stop_revision:
1853
 
                break
1854
 
            revision_id = iterator.next()
1855
 
            partial_history_cache.append(revision_id)
1856
 
    except StopIteration:
1857
 
        # No more history
1858
 
        return
1859
 
 
1860
 
 
1861
 
class _LazyListJoin(object):
1862
 
    """An iterable yielding the contents of many lists as one list.
1863
 
 
1864
 
    Each iterator made from this will reflect the current contents of the lists
1865
 
    at the time the iterator is made.
 
3078
        return _map[code]
 
3079
    except KeyError:
 
3080
        if not code.startswith('#'):
 
3081
            raise
 
3082
        return unichr(int(code[1:])).encode('utf8')
 
3083
 
 
3084
 
 
3085
_unescape_re = None
 
3086
 
 
3087
 
 
3088
def _unescape_xml(data):
 
3089
    """Unescape predefined XML entities in a string of data."""
 
3090
    global _unescape_re
 
3091
    if _unescape_re is None:
 
3092
        _unescape_re = re.compile('\&([^;]*);')
 
3093
    return _unescape_re.sub(_unescaper, data)
 
3094
 
 
3095
 
 
3096
class _VersionedFileChecker(object):
 
3097
 
 
3098
    def __init__(self, repository):
 
3099
        self.repository = repository
 
3100
        self.text_index = self.repository._generate_text_key_index()
1866
3101
    
1867
 
    This is used by Repository's _make_parents_provider implementation so that
1868
 
    it is safe to do::
1869
 
 
1870
 
      pp = repo._make_parents_provider()      # uses a list of fallback repos
1871
 
      pp.add_fallback_repository(other_repo)  # appends to that list
1872
 
      result = pp.get_parent_map(...)
1873
 
      # The result will include revs from other_repo
1874
 
    """
1875
 
 
1876
 
    def __init__(self, *list_parts):
1877
 
        self.list_parts = list_parts
1878
 
 
1879
 
    def __iter__(self):
1880
 
        full_list = []
1881
 
        for list_part in self.list_parts:
1882
 
            full_list.extend(list_part)
1883
 
        return iter(full_list)
1884
 
 
1885
 
    def __repr__(self):
1886
 
        return "%s.%s(%s)" % (self.__module__, self.__class__.__name__,
1887
 
                              self.list_parts)
 
3102
    def calculate_file_version_parents(self, revision_id, file_id):
 
3103
        """Calculate the correct parents for a file version according to
 
3104
        the inventories.
 
3105
        """
 
3106
        parent_keys = self.text_index[(file_id, revision_id)]
 
3107
        if parent_keys == [_mod_revision.NULL_REVISION]:
 
3108
            return ()
 
3109
        # strip the file_id, for the weave api
 
3110
        return tuple([revision_id for file_id, revision_id in parent_keys])
 
3111
 
 
3112
    def check_file_version_parents(self, weave, file_id):
 
3113
        """Check the parents stored in a versioned file are correct.
 
3114
 
 
3115
        It also detects file versions that are not referenced by their
 
3116
        corresponding revision's inventory.
 
3117
 
 
3118
        :returns: A tuple of (wrong_parents, dangling_file_versions).
 
3119
            wrong_parents is a dict mapping {revision_id: (stored_parents,
 
3120
            correct_parents)} for each revision_id where the stored parents
 
3121
            are not correct.  dangling_file_versions is a set of (file_id,
 
3122
            revision_id) tuples for versions that are present in this versioned
 
3123
            file, but not used by the corresponding inventory.
 
3124
        """
 
3125
        wrong_parents = {}
 
3126
        unused_versions = set()
 
3127
        for num, revision_id in enumerate(weave.versions()):
 
3128
            try:
 
3129
                correct_parents = self.calculate_file_version_parents(
 
3130
                    revision_id, file_id)
 
3131
            except KeyError:
 
3132
                # The version is not part of the used keys.
 
3133
                unused_versions.add(revision_id)
 
3134
            else:
 
3135
                try:
 
3136
                    knit_parents = tuple(weave.get_parents(revision_id))
 
3137
                except errors.RevisionNotPresent:
 
3138
                    knit_parents = None
 
3139
                if correct_parents != knit_parents:
 
3140
                    wrong_parents[revision_id] = (knit_parents, correct_parents)
 
3141
        return wrong_parents, unused_versions