← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

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