← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

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
16
 
17
17
from bzrlib.lazy_import import lazy_import
18
18
lazy_import(globals(), """
19
 
import cStringIO
20
 
import re
 
19
import itertools
21
20
import time
22
21
 
23
22
from bzrlib import (
24
23
    bzrdir,
25
 
    check,
 
24
    config,
 
25
    controldir,
26
26
    debug,
27
 
    errors,
28
27
    generate_ids,
29
 
    gpg,
30
28
    graph,
31
 
    lazy_regex,
32
29
    lockable_files,
33
30
    lockdir,
34
 
    lru_cache,
35
31
    osutils,
36
 
    remote,
37
32
    revision as _mod_revision,
38
 
    symbol_versioning,
 
33
    testament as _mod_testament,
39
34
    tsort,
40
 
    ui,
 
35
    gpg,
41
36
    )
42
37
from bzrlib.bundle import serializer
43
 
from bzrlib.revisiontree import RevisionTree
44
 
from bzrlib.store.versioned import VersionedFileStore
45
 
from bzrlib.testament import Testament
46
38
""")
47
39
 
48
 
from bzrlib import registry
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
40
from bzrlib import (
 
41
    errors,
 
42
    registry,
 
43
    symbol_versioning,
 
44
    ui,
 
45
    )
 
46
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
47
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
 
48
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
49
from bzrlib.trace import (
 
50
    log_exception_quietly, note, mutter, mutter_callsite, warning)
59
51
 
60
52
 
61
53
# Old formats display a warning, but only once
62
54
_deprecation_warning_done = False
63
55
 
64
56
 
 
57
class IsInWriteGroupError(errors.InternalBzrError):
 
58
 
 
59
    _fmt = "May not refresh_data of repo %(repo)s while in a write group."
 
60
 
 
61
    def __init__(self, repo):
 
62
        errors.InternalBzrError.__init__(self, repo=repo)
 
63
 
 
64
 
65
65
class CommitBuilder(object):
66
66
    """Provides an interface to build up a commit.
67
67
 
68
 
    This allows describing a tree to be committed without needing to 
 
68
    This allows describing a tree to be committed without needing to
69
69
    know the internals of the format of the repository.
70
70
    """
71
 
    
 
71
 
72
72
    # all clients should supply tree roots.
73
73
    record_root_entry = True
74
 
    # the default CommitBuilder does not manage trees whose root is versioned.
75
 
    _versioned_root = False
 
74
    # whether this commit builder supports the record_entry_contents interface
 
75
    supports_record_entry_contents = False
76
76
 
77
77
    def __init__(self, repository, parents, config, timestamp=None,
78
78
                 timezone=None, committer=None, revprops=None,
79
 
                 revision_id=None):
 
79
                 revision_id=None, lossy=False):
80
80
        """Initiate a CommitBuilder.
81
81
 
82
82
        :param repository: Repository to commit to.
83
83
        :param parents: Revision ids of the parents of the new revision.
84
 
        :param config: Configuration to use.
85
84
        :param timestamp: Optional timestamp recorded for commit.
86
85
        :param timezone: Optional timezone for timestamp.
87
86
        :param committer: Optional committer to set for commit.
88
87
        :param revprops: Optional dictionary of revision properties.
89
88
        :param revision_id: Optional revision id.
 
89
        :param lossy: Whether to discard data that can not be natively
 
90
            represented, when pushing to a foreign VCS 
90
91
        """
91
92
        self._config = config
 
93
        self._lossy = lossy
92
94
 
93
95
        if committer is None:
94
96
            self._committer = self._config.username()
 
97
        elif not isinstance(committer, unicode):
 
98
            self._committer = committer.decode() # throw if non-ascii
95
99
        else:
96
100
            self._committer = committer
97
101
 
98
 
        self.new_inventory = Inventory(None)
99
102
        self._new_revision_id = revision_id
100
103
        self.parents = parents
101
104
        self.repository = repository
102
105
 
103
106
        self._revprops = {}
104
107
        if revprops is not None:
 
108
            self._validate_revprops(revprops)
105
109
            self._revprops.update(revprops)
106
110
 
107
111
        if timestamp is None:
115
119
            self._timezone = int(timezone)
116
120
 
117
121
        self._generate_revision_if_needed()
118
 
        self.__heads = graph.HeadsCache(repository.get_graph()).heads
 
122
 
 
123
    def any_changes(self):
 
124
        """Return True if any entries were changed.
 
125
 
 
126
        This includes merge-only changes. It is the core for the --unchanged
 
127
        detection in commit.
 
128
 
 
129
        :return: True if any changes have occured.
 
130
        """
 
131
        raise NotImplementedError(self.any_changes)
 
132
 
 
133
    def _validate_unicode_text(self, text, context):
 
134
        """Verify things like commit messages don't have bogus characters."""
 
135
        if '\r' in text:
 
136
            raise ValueError('Invalid value for %s: %r' % (context, text))
 
137
 
 
138
    def _validate_revprops(self, revprops):
 
139
        for key, value in revprops.iteritems():
 
140
            # We know that the XML serializers do not round trip '\r'
 
141
            # correctly, so refuse to accept them
 
142
            if not isinstance(value, basestring):
 
143
                raise ValueError('revision property (%s) is not a valid'
 
144
                                 ' (unicode) string: %r' % (key, value))
 
145
            self._validate_unicode_text(value,
 
146
                                        'revision property (%s)' % (key,))
119
147
 
120
148
    def commit(self, message):
121
149
        """Make the actual commit.
122
150
 
123
151
        :return: The revision id of the recorded revision.
124
152
        """
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
 
153
        raise NotImplementedError(self.commit)
138
154
 
139
155
    def abort(self):
140
156
        """Abort the commit that is being built.
141
157
        """
142
 
        self.repository.abort_write_group()
 
158
        raise NotImplementedError(self.abort)
143
159
 
144
160
    def revision_tree(self):
145
161
        """Return the tree that was just committed.
146
162
 
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
 
163
        After calling commit() this can be called to get a
 
164
        RevisionTree representing the newly committed tree. This is
 
165
        preferred to calling Repository.revision_tree() because that may
 
166
        require deserializing the inventory, while we already have a copy in
151
167
        memory.
152
168
        """
153
 
        return RevisionTree(self.repository, self.new_inventory,
154
 
                            self._new_revision_id)
 
169
        raise NotImplementedError(self.revision_tree)
155
170
 
156
171
    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
 
            )
 
172
        """Tell the builder that the inventory is finished.
 
173
 
 
174
        :return: The inventory id in the repository, which can be used with
 
175
            repository.get_inventory.
 
176
        """
 
177
        raise NotImplementedError(self.finish_inventory)
168
178
 
169
179
    def _gen_revision_id(self):
170
180
        """Return new revision-id."""
171
 
        return generate_ids.gen_revision_id(self._config.username(),
172
 
                                            self._timestamp)
 
181
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
173
182
 
174
183
    def _generate_revision_if_needed(self):
175
184
        """Create a revision id if None was supplied.
176
 
        
 
185
 
177
186
        If the repository can not support user-specified revision ids
178
187
        they should override this function and raise CannotSetRevisionId
179
188
        if _new_revision_id is not None.
186
195
        else:
187
196
            self.random_revid = False
188
197
 
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
 
        """
 
198
    def will_record_deletes(self):
 
199
        """Tell the commit builder that deletes are being notified.
 
200
 
 
201
        This enables the accumulation of an inventory delta; for the resulting
 
202
        commit to be valid, deletes against the basis MUST be recorded via
 
203
        builder.record_delete().
 
204
        """
 
205
        raise NotImplementedError(self.will_record_deletes)
 
206
 
 
207
    def record_iter_changes(self, tree, basis_revision_id, iter_changes):
 
208
        """Record a new tree via iter_changes.
 
209
 
 
210
        :param tree: The tree to obtain text contents from for changed objects.
 
211
        :param basis_revision_id: The revision id of the tree the iter_changes
 
212
            has been generated against. Currently assumed to be the same
 
213
            as self.parents[0] - if it is not, errors may occur.
 
214
        :param iter_changes: An iter_changes iterator with the changes to apply
 
215
            to basis_revision_id. The iterator must not include any items with
 
216
            a current kind of None - missing items must be either filtered out
 
217
            or errored-on beefore record_iter_changes sees the item.
 
218
        :return: A generator of (file_id, relpath, fs_hash) tuples for use with
 
219
            tree._observed_sha1.
 
220
        """
 
221
        raise NotImplementedError(self.record_iter_changes)
 
222
 
 
223
 
 
224
class RepositoryWriteLockResult(LogicalLockResult):
 
225
    """The result of write locking a repository.
 
226
 
 
227
    :ivar repository_token: The token obtained from the underlying lock, or
 
228
        None.
 
229
    :ivar unlock: A callable which will unlock the lock.
 
230
    """
 
231
 
 
232
    def __init__(self, unlock, repository_token):
 
233
        LogicalLockResult.__init__(self, unlock)
 
234
        self.repository_token = repository_token
 
235
 
 
236
    def __repr__(self):
 
237
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
 
238
            self.unlock)
454
239
 
455
240
 
456
241
######################################################################
457
242
# Repositories
458
243
 
459
 
class Repository(object):
 
244
 
 
245
class Repository(_RelockDebugMixin, controldir.ControlComponent):
460
246
    """Repository holding history for one or more branches.
461
247
 
462
248
    The repository holds and retrieves historical information including
463
249
    revisions and file history.  It's normally accessed only by the Branch,
464
250
    which views a particular line of development through that history.
465
251
 
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.
 
252
    See VersionedFileRepository in bzrlib.vf_repository for the
 
253
    base class for most Bazaar repositories.
503
254
    """
504
255
 
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):
 
256
    def abort_write_group(self, suppress_errors=False):
517
257
        """Commit the contents accrued within the current write group.
518
258
 
 
259
        :param suppress_errors: if true, abort_write_group will catch and log
 
260
            unexpected errors that happen during the abort, rather than
 
261
            allowing them to propagate.  Defaults to False.
 
262
 
519
263
        :seealso: start_write_group.
520
264
        """
521
265
        if self._write_group is not self.get_transaction():
522
266
            # has an unlock or relock occured ?
523
 
            raise errors.BzrError('mismatched lock context and write group.')
524
 
        self._abort_write_group()
 
267
            if suppress_errors:
 
268
                mutter(
 
269
                '(suppressed) mismatched lock context and write group. %r, %r',
 
270
                self._write_group, self.get_transaction())
 
271
                return
 
272
            raise errors.BzrError(
 
273
                'mismatched lock context and write group. %r, %r' %
 
274
                (self._write_group, self.get_transaction()))
 
275
        try:
 
276
            self._abort_write_group()
 
277
        except Exception, exc:
 
278
            self._write_group = None
 
279
            if not suppress_errors:
 
280
                raise
 
281
            mutter('abort_write_group failed')
 
282
            log_exception_quietly()
 
283
            note('bzr: ERROR (ignored): %s', exc)
525
284
        self._write_group = None
526
285
 
527
286
    def _abort_write_group(self):
528
287
        """Template method for per-repository write group cleanup.
529
 
        
530
 
        This is called during abort before the write group is considered to be 
 
288
 
 
289
        This is called during abort before the write group is considered to be
531
290
        finished and should cleanup any internal state accrued during the write
532
291
        group. There is no requirement that data handed to the repository be
533
292
        *not* made available - this is not a rollback - but neither should any
539
298
 
540
299
    def add_fallback_repository(self, repository):
541
300
        """Add a repository to use for looking up data not held locally.
542
 
        
 
301
 
543
302
        :param repository: A repository.
544
303
        """
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)
 
304
        raise NotImplementedError(self.add_fallback_repository)
553
305
 
554
306
    def _check_fallback_repository(self, repository):
555
307
        """Check that this repository can fallback to repository safely.
556
308
 
557
309
        Raise an error if not.
558
 
        
 
310
 
559
311
        :param repository: A repository to fallback to.
560
312
        """
561
313
        return InterRepository._assert_same_model(self, repository)
562
314
 
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
315
    def all_revision_ids(self):
634
 
        """Returns a list of all the revision ids in the repository. 
 
316
        """Returns a list of all the revision ids in the repository.
635
317
 
636
318
        This is conceptually deprecated because code should generally work on
637
319
        the graph reachable from a particular revision, and ignore any other
643
325
        return self._all_revision_ids()
644
326
 
645
327
    def _all_revision_ids(self):
646
 
        """Returns a list of all the revision ids in the repository. 
 
328
        """Returns a list of all the revision ids in the repository.
647
329
 
648
 
        These are in as much topological order as the underlying store can 
 
330
        These are in as much topological order as the underlying store can
649
331
        present.
650
332
        """
651
333
        raise NotImplementedError(self._all_revision_ids)
658
340
        """
659
341
        self.control_files.break_lock()
660
342
 
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
343
    @staticmethod
674
344
    def create(a_bzrdir):
675
345
        """Construct the current default format repository in a_bzrdir."""
680
350
 
681
351
        :param _format: The format of the repository on disk.
682
352
        :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.
 
353
        :param control_files: Control files to use for locking, etc.
687
354
        """
 
355
        # In the future we will have a single api for all stores for
 
356
        # getting file texts, inventories and revisions, then
 
357
        # this construct will accept instances of those things.
688
358
        super(Repository, self).__init__()
689
359
        self._format = _format
690
360
        # the following are part of the public API for Repository:
693
363
        self._transport = control_files._transport
694
364
        self.base = self._transport.base
695
365
        # 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
366
        self._write_group = None
705
367
        # Additional places to query for data.
706
368
        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
 
369
 
 
370
    @property
 
371
    def user_transport(self):
 
372
        return self.bzrdir.user_transport
 
373
 
 
374
    @property
 
375
    def control_transport(self):
 
376
        return self._transport
719
377
 
720
378
    def __repr__(self):
721
 
        return '%s(%r)' % (self.__class__.__name__,
722
 
                           self.base)
 
379
        if self._fallback_repositories:
 
380
            return '%s(%r, fallback_repositories=%r)' % (
 
381
                self.__class__.__name__,
 
382
                self.base,
 
383
                self._fallback_repositories)
 
384
        else:
 
385
            return '%s(%r)' % (self.__class__.__name__,
 
386
                               self.base)
 
387
 
 
388
    def _has_same_fallbacks(self, other_repo):
 
389
        """Returns true if the repositories have the same fallbacks."""
 
390
        my_fb = self._fallback_repositories
 
391
        other_fb = other_repo._fallback_repositories
 
392
        if len(my_fb) != len(other_fb):
 
393
            return False
 
394
        for f, g in zip(my_fb, other_fb):
 
395
            if not f.has_same_location(g):
 
396
                return False
 
397
        return True
723
398
 
724
399
    def has_same_location(self, other):
725
400
        """Returns a boolean indicating if this repository is at the same
752
427
        This causes caching within the repository obejct to start accumlating
753
428
        data during reads, and allows a 'write_group' to be obtained. Write
754
429
        groups must be used for actual data insertion.
755
 
        
 
430
 
 
431
        A token should be passed in if you know that you have locked the object
 
432
        some other way, and need to synchronise this object's state with that
 
433
        fact.
 
434
 
 
435
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
 
436
 
756
437
        :param token: if this is already locked, then lock_write will fail
757
438
            unless the token matches the existing lock.
758
439
        :returns: a token if this instance supports tokens, otherwise None.
761
442
        :raises MismatchedToken: if the specified token doesn't match the token
762
443
            of the existing lock.
763
444
        :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
 
445
        :return: A RepositoryWriteLockResult.
770
446
        """
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
 
447
        locked = self.is_locked()
 
448
        token = self.control_files.lock_write(token=token)
 
449
        if not locked:
 
450
            self._warn_if_deprecated()
 
451
            self._note_lock('w')
 
452
            for repo in self._fallback_repositories:
 
453
                # Writes don't affect fallback repos
 
454
                repo.lock_read()
 
455
            self._refresh_data()
 
456
        return RepositoryWriteLockResult(self.unlock, token)
777
457
 
778
458
    def lock_read(self):
 
459
        """Lock the repository for read operations.
 
460
 
 
461
        :return: An object with an unlock method which will release the lock
 
462
            obtained.
 
463
        """
 
464
        locked = self.is_locked()
779
465
        self.control_files.lock_read()
780
 
        for repo in self._fallback_repositories:
781
 
            repo.lock_read()
782
 
        self._refresh_data()
 
466
        if not locked:
 
467
            self._warn_if_deprecated()
 
468
            self._note_lock('r')
 
469
            for repo in self._fallback_repositories:
 
470
                repo.lock_read()
 
471
            self._refresh_data()
 
472
        return LogicalLockResult(self.unlock)
783
473
 
784
474
    def get_physical_lock_status(self):
785
475
        return self.control_files.get_physical_lock_status()
787
477
    def leave_lock_in_place(self):
788
478
        """Tell this repository not to release the physical lock when this
789
479
        object is unlocked.
790
 
        
 
480
 
791
481
        If lock_write doesn't return a token, then this method is not supported.
792
482
        """
793
483
        self.control_files.leave_in_place()
821
511
        if revid and committers:
822
512
            result['committers'] = 0
823
513
        if revid and revid != _mod_revision.NULL_REVISION:
 
514
            graph = self.get_graph()
824
515
            if committers:
825
516
                all_committers = set()
826
 
            revisions = self.get_ancestry(revid)
827
 
            # pop the leading None
828
 
            revisions.pop(0)
829
 
            first_revision = None
 
517
            revisions = [r for (r, p) in graph.iter_ancestry([revid])
 
518
                        if r != _mod_revision.NULL_REVISION]
 
519
            last_revision = None
830
520
            if not committers:
831
521
                # ignore the revisions in the middle - just grab first and last
832
522
                revisions = revisions[0], revisions[-1]
833
523
            for revision in self.get_revisions(revisions):
834
 
                if not first_revision:
835
 
                    first_revision = revision
 
524
                if not last_revision:
 
525
                    last_revision = revision
836
526
                if committers:
837
527
                    all_committers.add(revision.committer)
838
 
            last_revision = revision
 
528
            first_revision = revision
839
529
            if committers:
840
530
                result['committers'] = len(all_committers)
841
531
            result['firstrev'] = (first_revision.timestamp,
842
532
                first_revision.timezone)
843
533
            result['latestrev'] = (last_revision.timestamp,
844
534
                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
535
        return result
855
536
 
856
537
    def find_branches(self, using=False):
861
542
        :param using: If True, list only branches using this repository.
862
543
        """
863
544
        if using and not self.is_shared():
864
 
            try:
865
 
                return [self.bzrdir.open_branch()]
866
 
            except errors.NotBranchError:
867
 
                return []
 
545
            return self.bzrdir.list_branches()
868
546
        class Evaluator(object):
869
547
 
870
548
            def __init__(self):
879
557
                    except errors.NoRepositoryPresent:
880
558
                        pass
881
559
                    else:
882
 
                        return False, (None, repository)
 
560
                        return False, ([], repository)
883
561
                self.first_call = False
884
 
                try:
885
 
                    value = (bzrdir.open_branch(), None)
886
 
                except errors.NotBranchError:
887
 
                    value = (None, None)
 
562
                value = (bzrdir.list_branches(), None)
888
563
                return True, value
889
564
 
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)
 
565
        ret = []
 
566
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
 
567
                self.user_transport, evaluate=Evaluator()):
 
568
            if branches is not None:
 
569
                ret.extend(branches)
895
570
            if not using and repository is not None:
896
 
                branches.extend(repository.find_branches())
897
 
        return branches
 
571
                ret.extend(repository.find_branches())
 
572
        return ret
898
573
 
899
574
    @needs_read_lock
900
 
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
 
575
    def search_missing_revision_ids(self, other,
 
576
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
577
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
578
            limit=None):
901
579
        """Return the revision ids that other has that this does not.
902
 
        
 
580
 
903
581
        These are returned in topological order.
904
582
 
905
583
        revision_id: only return revision ids included by revision_id.
906
584
        """
 
585
        if symbol_versioning.deprecated_passed(revision_id):
 
586
            symbol_versioning.warn(
 
587
                'search_missing_revision_ids(revision_id=...) was '
 
588
                'deprecated in 2.4.  Use revision_ids=[...] instead.',
 
589
                DeprecationWarning, stacklevel=3)
 
590
            if revision_ids is not None:
 
591
                raise AssertionError(
 
592
                    'revision_ids is mutually exclusive with revision_id')
 
593
            if revision_id is not None:
 
594
                revision_ids = [revision_id]
907
595
        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)
 
596
            find_ghosts=find_ghosts, revision_ids=revision_ids,
 
597
            if_present_ids=if_present_ids, limit=limit)
927
598
 
928
599
    @staticmethod
929
600
    def open(base):
937
608
 
938
609
    def copy_content_into(self, destination, revision_id=None):
939
610
        """Make a complete copy of the content in self into destination.
940
 
        
941
 
        This is a destructive operation! Do not use it on existing 
 
611
 
 
612
        This is a destructive operation! Do not use it on existing
942
613
        repositories.
943
614
        """
944
615
        return InterRepository.get(self, destination).copy_content(revision_id)
947
618
        """Commit the contents accrued within the current write group.
948
619
 
949
620
        :seealso: start_write_group.
 
621
        
 
622
        :return: it may return an opaque hint that can be passed to 'pack'.
950
623
        """
951
624
        if self._write_group is not self.get_transaction():
952
625
            # has an unlock or relock occured ?
953
626
            raise errors.BzrError('mismatched lock context %r and '
954
627
                'write group %r.' %
955
628
                (self.get_transaction(), self._write_group))
956
 
        self._commit_write_group()
 
629
        result = self._commit_write_group()
957
630
        self._write_group = None
 
631
        return result
958
632
 
959
633
    def _commit_write_group(self):
960
634
        """Template method for per-repository write group cleanup.
961
 
        
962
 
        This is called before the write group is considered to be 
 
635
 
 
636
        This is called before the write group is considered to be
963
637
        finished and should ensure that all data handed to the repository
964
 
        for writing during the write group is safely committed (to the 
 
638
        for writing during the write group is safely committed (to the
965
639
        extent possible considering file system caching etc).
966
640
        """
967
641
 
968
 
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False):
 
642
    def suspend_write_group(self):
 
643
        raise errors.UnsuspendableWriteGroup(self)
 
644
 
 
645
    def refresh_data(self):
 
646
        """Re-read any data needed to synchronise with disk.
 
647
 
 
648
        This method is intended to be called after another repository instance
 
649
        (such as one used by a smart server) has inserted data into the
 
650
        repository. On all repositories this will work outside of write groups.
 
651
        Some repository formats (pack and newer for bzrlib native formats)
 
652
        support refresh_data inside write groups. If called inside a write
 
653
        group on a repository that does not support refreshing in a write group
 
654
        IsInWriteGroupError will be raised.
 
655
        """
 
656
        self._refresh_data()
 
657
 
 
658
    def resume_write_group(self, tokens):
 
659
        if not self.is_write_locked():
 
660
            raise errors.NotWriteLocked(self)
 
661
        if self._write_group:
 
662
            raise errors.BzrError('already in a write group')
 
663
        self._resume_write_group(tokens)
 
664
        # so we can detect unlock/relock - the write group is now entered.
 
665
        self._write_group = self.get_transaction()
 
666
 
 
667
    def _resume_write_group(self, tokens):
 
668
        raise errors.UnsuspendableWriteGroup(self)
 
669
 
 
670
    def fetch(self, source, revision_id=None, find_ghosts=False,
 
671
            fetch_spec=None):
969
672
        """Fetch the content required to construct revision_id from source.
970
673
 
971
 
        If revision_id is None all content is copied.
 
674
        If revision_id is None and fetch_spec is None, then all content is
 
675
        copied.
 
676
 
 
677
        fetch() may not be used when the repository is in a write group -
 
678
        either finish the current write group before using fetch, or use
 
679
        fetch before starting the write group.
 
680
 
972
681
        :param find_ghosts: Find and copy revisions in the source that are
973
682
            ghosts in the target (and not reachable directly by walking out to
974
683
            the first-present revision in target from revision_id).
 
684
        :param revision_id: If specified, all the content needed for this
 
685
            revision ID will be copied to the target.  Fetch will determine for
 
686
            itself which content needs to be copied.
 
687
        :param fetch_spec: If specified, a SearchResult or
 
688
            PendingAncestryResult that describes which revisions to copy.  This
 
689
            allows copying multiple heads at once.  Mutually exclusive with
 
690
            revision_id.
975
691
        """
 
692
        if fetch_spec is not None and revision_id is not None:
 
693
            raise AssertionError(
 
694
                "fetch_spec and revision_id are mutually exclusive.")
 
695
        if self.is_in_write_group():
 
696
            raise errors.InternalBzrError(
 
697
                "May not fetch while in a write group.")
976
698
        # fast path same-url fetch operations
977
 
        if self.has_same_location(source):
 
699
        # TODO: lift out to somewhere common with RemoteRepository
 
700
        # <https://bugs.launchpad.net/bzr/+bug/401646>
 
701
        if (self.has_same_location(source)
 
702
            and fetch_spec is None
 
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,
 
712
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
990
713
 
991
714
    def create_bundle(self, target, base, fileobj, format=None):
992
715
        return serializer.write_bundle(self, target, base, fileobj, format)
993
716
 
994
717
    def get_commit_builder(self, branch, parents, config, timestamp=None,
995
718
                           timezone=None, committer=None, revprops=None,
996
 
                           revision_id=None):
 
719
                           revision_id=None, lossy=False):
997
720
        """Obtain a CommitBuilder for this repository.
998
 
        
 
721
 
999
722
        :param branch: Branch to commit to.
1000
723
        :param parents: Revision ids of the parents of the new revision.
1001
724
        :param config: Configuration to use.
1004
727
        :param committer: Optional committer to set for commit.
1005
728
        :param revprops: Optional dictionary of revision properties.
1006
729
        :param revision_id: Optional revision id.
 
730
        :param lossy: Whether to discard data that can not be natively
 
731
            represented, when pushing to a foreign VCS
1007
732
        """
1008
 
        result = self._commit_builder_class(self, parents, config,
1009
 
            timestamp, timezone, committer, revprops, revision_id)
1010
 
        self.start_write_group()
1011
 
        return result
 
733
        raise NotImplementedError(self.get_commit_builder)
1012
734
 
 
735
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1013
736
    def unlock(self):
1014
737
        if (self.control_files._lock_count == 1 and
1015
738
            self.control_files._lock_mode == 'w'):
1019
742
                raise errors.BzrError(
1020
743
                    'Must end write groups before releasing write locks.')
1021
744
        self.control_files.unlock()
1022
 
        for repo in self._fallback_repositories:
1023
 
            repo.unlock()
 
745
        if self.control_files._lock_count == 0:
 
746
            for repo in self._fallback_repositories:
 
747
                repo.unlock()
1024
748
 
1025
749
    @needs_read_lock
1026
750
    def clone(self, a_bzrdir, revision_id=None):
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):
 
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
 
932
 
 
933
    def fileids_altered_by_revision_ids(self, revision_ids):
1329
934
        """Find the file ids and versions affected by revisions.
1330
935
 
1331
936
        :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
937
        :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.
 
938
            revision_ids. Each altered file-ids has the exact revision_ids
 
939
            that altered it listed explicitly.
1337
940
        """
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()
 
941
        raise NotImplementedError(self.fileids_altered_by_revision_ids)
1348
942
 
1349
943
    def iter_files_bytes(self, desired_files):
1350
944
        """Iterate through file versions.
1357
951
        uniquely identify the file version in the caller's context.  (Examples:
1358
952
        an index number or a TreeTransform trans_id.)
1359
953
 
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
954
        :param desired_files: a list of (file_id, revision_id, identifier)
1366
955
            triples
1367
956
        """
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
 
 
 
957
        raise NotImplementedError(self.iter_files_bytes)
 
958
 
 
959
    def get_rev_id_for_revno(self, revno, known_pair):
 
960
        """Return the revision id of a revno, given a later (revno, revid)
 
961
        pair in the same history.
 
962
 
 
963
        :return: if found (True, revid).  If the available history ran out
 
964
            before reaching the revno, then this returns
 
965
            (False, (closest_revno, closest_revid)).
 
966
        """
 
967
        known_revno, known_revid = known_pair
 
968
        partial_history = [known_revid]
 
969
        distance_from_known = known_revno - revno
 
970
        if distance_from_known < 0:
 
971
            raise ValueError(
 
972
                'requested revno (%d) is later than given known revno (%d)'
 
973
                % (revno, known_revno))
 
974
        try:
 
975
            _iter_for_revno(
 
976
                self, partial_history, stop_index=distance_from_known)
 
977
        except errors.RevisionNotPresent, err:
 
978
            if err.revision_id == known_revid:
 
979
                # The start revision (known_revid) wasn't found.
 
980
                raise
 
981
            # This is a stacked repository with no fallbacks, or a there's a
 
982
            # left-hand ghost.  Either way, even though the revision named in
 
983
            # the error isn't in this repo, we know it's the next step in this
 
984
            # left-hand history.
 
985
            partial_history.append(err.revision_id)
 
986
        if len(partial_history) <= distance_from_known:
 
987
            # Didn't find enough history to get a revid for the revno.
 
988
            earliest_revno = known_revno - len(partial_history) + 1
 
989
            return (False, (earliest_revno, partial_history[-1]))
 
990
        if len(partial_history) - 1 > distance_from_known:
 
991
            raise AssertionError('_iter_for_revno returned too much history')
 
992
        return (True, partial_history[-1])
 
993
 
 
994
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1604
995
    def iter_reverse_revision_history(self, revision_id):
1605
996
        """Iterate backwards through revision ids in the lefthand history
1606
997
 
1608
999
            ancestors will be traversed.
1609
1000
        """
1610
1001
        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)
 
1002
        stop_revisions = (None, _mod_revision.NULL_REVISION)
 
1003
        return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
1642
1004
 
1643
1005
    def is_shared(self):
1644
1006
        """Return True if this repository is flagged as a shared repository."""
1659
1021
        for repositories to maintain loaded indices across multiple locks
1660
1022
        by checking inside their implementation of this method to see
1661
1023
        whether their indices are still valid. This depends of course on
1662
 
        the disk format being validatable in this manner.
 
1024
        the disk format being validatable in this manner. This method is
 
1025
        also called by the refresh_data() public interface to cause a refresh
 
1026
        to occur while in a write lock so that data inserted by a smart server
 
1027
        push operation is visible on the client's instance of the physical
 
1028
        repository.
1663
1029
        """
1664
1030
 
1665
1031
    @needs_read_lock
1668
1034
 
1669
1035
        `revision_id` may be NULL_REVISION for the empty tree revision.
1670
1036
        """
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)
 
1037
        raise NotImplementedError(self.revision_tree)
1680
1038
 
1681
1039
    def revision_trees(self, revision_ids):
1682
 
        """Return Tree for a revision on this branch.
 
1040
        """Return Trees for revisions in this repository.
1683
1041
 
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)
 
1042
        :param revision_ids: a sequence of revision-ids;
 
1043
          a revision-id may not be None or 'null:'
 
1044
        """
 
1045
        raise NotImplementedError(self.revision_trees)
1688
1046
 
1689
1047
    @needs_read_lock
 
1048
    @symbol_versioning.deprecated_method(
 
1049
        symbol_versioning.deprecated_in((2, 4, 0)))
1690
1050
    def get_ancestry(self, revision_id, topo_sorted=True):
1691
1051
        """Return a list of revision-ids integrated by a revision.
1692
1052
 
1693
 
        The first element of the list is always None, indicating the origin 
1694
 
        revision.  This might change when we have history horizons, or 
 
1053
        The first element of the list is always None, indicating the origin
 
1054
        revision.  This might change when we have history horizons, or
1695
1055
        perhaps we should have a new API.
1696
 
        
 
1056
 
1697
1057
        This is topologically sorted.
1698
1058
        """
 
1059
        if 'evil' in debug.debug_flags:
 
1060
            mutter_callsite(2, "get_ancestry is linear with history.")
1699
1061
        if _mod_revision.is_null(revision_id):
1700
1062
            return [None]
1701
1063
        if not self.has_revision(revision_id):
1716
1078
            keys = tsort.topo_sort(parent_map)
1717
1079
        return [None] + list(keys)
1718
1080
 
1719
 
    def pack(self):
 
1081
    def pack(self, hint=None, clean_obsolete_packs=False):
1720
1082
        """Compress the data within the repository.
1721
1083
 
1722
1084
        This operation only makes sense for some repository types. For other
1723
1085
        types it should be a no-op that just returns.
1724
1086
 
1725
1087
        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 
 
1088
        @needs_write_lock as this is a long running call it's reasonable to
1727
1089
        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)
 
1090
 
 
1091
        :param hint: If not supplied, the whole repository is packed.
 
1092
            If supplied, the repository may use the hint parameter as a
 
1093
            hint for the parts of the repository to pack. A hint can be
 
1094
            obtained from the result of commit_write_group(). Out of
 
1095
            date hints are simply ignored, because concurrent operations
 
1096
            can obsolete them rapidly.
 
1097
 
 
1098
        :param clean_obsolete_packs: Clean obsolete packs immediately after
 
1099
            the pack operation.
 
1100
        """
1748
1101
 
1749
1102
    def get_transaction(self):
1750
1103
        return self.control_files.get_transaction()
1751
1104
 
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
1105
    def get_parent_map(self, revision_ids):
1759
 
        """See graph._StackedParentsProvider.get_parent_map"""
 
1106
        """See graph.StackedParentsProvider.get_parent_map"""
 
1107
        raise NotImplementedError(self.get_parent_map)
 
1108
 
 
1109
    def _get_parent_map_no_fallbacks(self, revision_ids):
 
1110
        """Same as Repository.get_parent_map except doesn't query fallbacks."""
1760
1111
        # revisions index works in keys; this just works in revisions
1761
1112
        # therefore wrap and unwrap
1762
1113
        query_keys = []
1768
1119
                raise ValueError('get_parent_map(None) is not valid')
1769
1120
            else:
1770
1121
                query_keys.append((revision_id ,))
 
1122
        vf = self.revisions.without_fallbacks()
1771
1123
        for ((revision_id,), parent_keys) in \
1772
 
                self.revisions.get_parent_map(query_keys).iteritems():
 
1124
                vf.get_parent_map(query_keys).iteritems():
1773
1125
            if parent_keys:
1774
 
                result[revision_id] = tuple(parent_revid
1775
 
                    for (parent_revid,) in parent_keys)
 
1126
                result[revision_id] = tuple([parent_revid
 
1127
                    for (parent_revid,) in parent_keys])
1776
1128
            else:
1777
1129
                result[revision_id] = (_mod_revision.NULL_REVISION,)
1778
1130
        return result
1779
1131
 
1780
1132
    def _make_parents_provider(self):
1781
 
        return self
 
1133
        if not self._format.supports_external_lookups:
 
1134
            return self
 
1135
        return graph.StackedParentsProvider(_LazyListJoin(
 
1136
            [self._make_parents_provider_unstacked()],
 
1137
            self._fallback_repositories))
 
1138
 
 
1139
    def _make_parents_provider_unstacked(self):
 
1140
        return graph.CallableToParentsProviderAdapter(
 
1141
            self._get_parent_map_no_fallbacks)
 
1142
 
 
1143
    @needs_read_lock
 
1144
    def get_known_graph_ancestry(self, revision_ids):
 
1145
        """Return the known graph for a set of revision ids and their ancestors.
 
1146
        """
 
1147
        raise NotImplementedError(self.get_known_graph_ancestry)
 
1148
 
 
1149
    def get_file_graph(self):
 
1150
        """Return the graph walker for files."""
 
1151
        raise NotImplementedError(self.get_file_graph)
1782
1152
 
1783
1153
    def get_graph(self, other_repository=None):
1784
1154
        """Return the graph walker for this repository format"""
1785
1155
        parents_provider = self._make_parents_provider()
1786
1156
        if (other_repository is not None and
1787
1157
            not self.has_same_location(other_repository)):
1788
 
            parents_provider = graph._StackedParentsProvider(
 
1158
            parents_provider = graph.StackedParentsProvider(
1789
1159
                [parents_provider, other_repository._make_parents_provider()])
1790
1160
        return graph.Graph(parents_provider)
1791
1161
 
1792
 
    def _get_versioned_file_checker(self):
1793
 
        """Return an object suitable for checking versioned files."""
1794
 
        return _VersionedFileChecker(self)
1795
 
 
1796
1162
    def revision_ids_to_search_result(self, result_set):
1797
1163
        """Convert a set of revision ids to a graph SearchResult."""
1798
1164
        result_parents = set()
1817
1183
                          working trees.
1818
1184
        """
1819
1185
        raise NotImplementedError(self.set_make_working_trees)
1820
 
    
 
1186
 
1821
1187
    def make_working_trees(self):
1822
1188
        """Returns the policy for making working trees on new branches."""
1823
1189
        raise NotImplementedError(self.make_working_trees)
1824
1190
 
1825
1191
    @needs_write_lock
1826
1192
    def sign_revision(self, revision_id, gpg_strategy):
1827
 
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
 
1193
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
1194
        plaintext = testament.as_short_text()
1828
1195
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1829
1196
 
1830
1197
    @needs_read_lock
 
1198
    def verify_revision(self, revision_id, gpg_strategy):
 
1199
        """Verify the signature on a revision.
 
1200
        
 
1201
        :param revision_id: the revision to verify
 
1202
        :gpg_strategy: the GPGStrategy object to used
 
1203
        
 
1204
        :return: gpg.SIGNATURE_VALID or a failed SIGNATURE_ value
 
1205
        """
 
1206
        if not self.has_signature_for_revision_id(revision_id):
 
1207
            return gpg.SIGNATURE_NOT_SIGNED, None
 
1208
        signature = self.get_signature_text(revision_id)
 
1209
 
 
1210
        testament = _mod_testament.Testament.from_revision(self, revision_id)
 
1211
        plaintext = testament.as_short_text()
 
1212
 
 
1213
        return gpg_strategy.verify(signature, plaintext)
 
1214
 
1831
1215
    def has_signature_for_revision_id(self, revision_id):
1832
1216
        """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
 
1217
        raise NotImplementedError(self.has_signature_for_revision_id)
1838
1218
 
1839
 
    @needs_read_lock
1840
1219
    def get_signature_text(self, revision_id):
1841
1220
        """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')
 
1221
        raise NotImplementedError(self.get_signature_text)
1848
1222
 
1849
 
    @needs_read_lock
1850
 
    def check(self, revision_ids=None):
 
1223
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
1851
1224
        """Check consistency of all history of given revision_ids.
1852
1225
 
1853
1226
        Different repository implementations should override _check().
1854
1227
 
1855
1228
        :param revision_ids: A non-empty list of revision_ids whose ancestry
1856
1229
             will be checked.  Typically the last revision_id of a branch.
 
1230
        :param callback_refs: A dict of check-refs to resolve and callback
 
1231
            the check/_check method on the items listed as wanting the ref.
 
1232
            see bzrlib.check.
 
1233
        :param check_repo: If False do not check the repository contents, just 
 
1234
            calculate the data callback_refs requires and call them back.
1857
1235
        """
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):
 
1236
        return self._check(revision_ids=revision_ids, callback_refs=callback_refs,
 
1237
            check_repo=check_repo)
 
1238
 
 
1239
    def _check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
1240
        raise NotImplementedError(self.check)
 
1241
 
 
1242
    def _warn_if_deprecated(self, branch=None):
 
1243
        if not self._format.is_deprecated():
 
1244
            return
1866
1245
        global _deprecation_warning_done
1867
1246
        if _deprecation_warning_done:
1868
1247
            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))
 
1248
        try:
 
1249
            if branch is None:
 
1250
                conf = config.GlobalConfig()
 
1251
            else:
 
1252
                conf = branch.get_config()
 
1253
            if conf.suppress_warning('format_deprecation'):
 
1254
                return
 
1255
            warning("Format %s for %s is deprecated -"
 
1256
                    " please use 'bzr upgrade' to get better performance"
 
1257
                    % (self._format, self.bzrdir.transport.base))
 
1258
        finally:
 
1259
            _deprecation_warning_done = True
1872
1260
 
1873
1261
    def supports_rich_root(self):
1874
1262
        return self._format.rich_root_data
1888
1276
                    revision_id.decode('ascii')
1889
1277
                except UnicodeDecodeError:
1890
1278
                    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
1279
 
2012
1280
 
2013
1281
class MetaDirRepository(Repository):
2014
1282
    """Repositories in the new meta-dir layout.
2015
 
    
 
1283
 
2016
1284
    :ivar _transport: Transport for access to repository control files,
2017
1285
        typically pointing to .bzr/repository.
2018
1286
    """
2043
1311
        else:
2044
1312
            self._transport.put_bytes('no-working-trees', '',
2045
1313
                mode=self.bzrdir._get_file_mode())
2046
 
    
 
1314
 
2047
1315
    def make_working_trees(self):
2048
1316
        """Returns the policy for making working trees on new branches."""
2049
1317
        return not self._transport.has('no-working-trees')
2050
1318
 
2051
1319
 
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.
 
1320
class RepositoryFormatRegistry(controldir.ControlComponentFormatRegistry):
 
1321
    """Repository format registry."""
 
1322
 
 
1323
    def get_default(self):
 
1324
        """Return the current default format."""
 
1325
        from bzrlib import bzrdir
 
1326
        return bzrdir.format_registry.make_bzrdir('default').repository_format
 
1327
 
 
1328
 
 
1329
network_format_registry = registry.FormatRegistry()
 
1330
"""Registry of formats indexed by their network name.
 
1331
 
 
1332
The network name for a repository format is an identifier that can be used when
 
1333
referring to formats with smart server operations. See
 
1334
RepositoryFormat.network_name() for more detail.
 
1335
"""
 
1336
 
 
1337
 
 
1338
format_registry = RepositoryFormatRegistry(network_format_registry)
 
1339
"""Registry of formats, indexed by their BzrDirMetaFormat format string.
2072
1340
 
2073
1341
This can contain either format instances themselves, or classes/factories that
2074
1342
can be called to obtain one.
2078
1346
#####################################################################
2079
1347
# Repository Formats
2080
1348
 
2081
 
class RepositoryFormat(object):
 
1349
class RepositoryFormat(controldir.ControlComponentFormat):
2082
1350
    """A repository format.
2083
1351
 
2084
 
    Formats provide three things:
 
1352
    Formats provide four things:
2085
1353
     * An initialization routine to construct repository data on disk.
2086
 
     * a format string which is used when the BzrDir supports versioned
2087
 
       children.
 
1354
     * a optional format string which is used when the BzrDir supports
 
1355
       versioned children.
2088
1356
     * an open routine which returns a Repository instance.
 
1357
     * A network name for referring to the format in smart server RPC
 
1358
       methods.
2089
1359
 
2090
1360
    There is one and only one Format subclass for each on-disk format. But
2091
1361
    there can be one Repository subclass that is used for several different
2092
1362
    formats. The _format attribute on a Repository instance can be used to
2093
1363
    determine the disk format.
2094
1364
 
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.
 
1365
    Formats are placed in a registry by their format string for reference
 
1366
    during opening. These should be subclasses of RepositoryFormat for
 
1367
    consistency.
2098
1368
 
2099
1369
    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.
 
1370
    methods on the format class. Do not deprecate the object, as the
 
1371
    object may be created even when a repository instance hasn't been
 
1372
    created.
2102
1373
 
2103
1374
    Common instance attributes:
2104
1375
    _matchingbzrdir - the bzrdir format that the repository format was
2113
1384
    # Can this repository be given external locations to lookup additional
2114
1385
    # data. Set to True or False in derived classes.
2115
1386
    supports_external_lookups = None
 
1387
    # Does this format support CHK bytestring lookups. Set to True or False in
 
1388
    # derived classes.
 
1389
    supports_chks = None
 
1390
    # Should fetch trigger a reconcile after the fetch? Only needed for
 
1391
    # some repository formats that can suffer internal inconsistencies.
 
1392
    _fetch_reconcile = False
 
1393
    # Does this format have < O(tree_size) delta generation. Used to hint what
 
1394
    # code path for commit, amongst other things.
 
1395
    fast_deltas = None
 
1396
    # Does doing a pack operation compress data? Useful for the pack UI command
 
1397
    # (so if there is one pack, the operation can still proceed because it may
 
1398
    # help), and for fetching when data won't have come from the same
 
1399
    # compressor.
 
1400
    pack_compresses = False
 
1401
    # Does the repository storage understand references to trees?
 
1402
    supports_tree_reference = None
 
1403
    # Is the format experimental ?
 
1404
    experimental = False
 
1405
    # Does this repository format escape funky characters, or does it create
 
1406
    # files with similar names as the versioned files in its contents on disk
 
1407
    # ?
 
1408
    supports_funky_characters = None
 
1409
    # Does this repository format support leaving locks?
 
1410
    supports_leaving_lock = None
 
1411
    # Does this format support the full VersionedFiles interface?
 
1412
    supports_full_versioned_files = None
 
1413
    # Does this format support signing revision signatures?
 
1414
    supports_revision_signatures = True
 
1415
    # Can the revision graph have incorrect parents?
 
1416
    revision_graph_can_have_wrong_parents = None
 
1417
    # Does this format support rich root data?
 
1418
    rich_root_data = None
 
1419
    # Does this format support explicitly versioned directories?
 
1420
    supports_versioned_directories = None
2116
1421
 
2117
 
    def __str__(self):
2118
 
        return "<%s>" % self.__class__.__name__
 
1422
    def __repr__(self):
 
1423
        return "%s()" % self.__class__.__name__
2119
1424
 
2120
1425
    def __eq__(self, other):
2121
1426
        # format objects are generally stateless
2127
1432
    @classmethod
2128
1433
    def find_format(klass, a_bzrdir):
2129
1434
        """Return the format for the repository object in a_bzrdir.
2130
 
        
 
1435
 
2131
1436
        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 
 
1437
        the repository.  Other methods may be used by different types of
2133
1438
        control directory.
2134
1439
        """
2135
1440
        try:
2136
1441
            transport = a_bzrdir.get_repository_transport(None)
2137
 
            format_string = transport.get("format").read()
 
1442
            format_string = transport.get_bytes("format")
2138
1443
            return format_registry.get(format_string)
2139
1444
        except errors.NoSuchFile:
2140
1445
            raise errors.NoRepositoryPresent(a_bzrdir)
2143
1448
                                            kind='repository')
2144
1449
 
2145
1450
    @classmethod
 
1451
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2146
1452
    def register_format(klass, format):
2147
 
        format_registry.register(format.get_format_string(), format)
 
1453
        format_registry.register(format)
2148
1454
 
2149
1455
    @classmethod
 
1456
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2150
1457
    def unregister_format(klass, format):
2151
 
        format_registry.remove(format.get_format_string())
2152
 
    
 
1458
        format_registry.remove(format)
 
1459
 
2153
1460
    @classmethod
 
1461
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2154
1462
    def get_default_format(klass):
2155
1463
        """Return the current default format."""
2156
 
        from bzrlib import bzrdir
2157
 
        return bzrdir.format_registry.make_bzrdir('default').repository_format
 
1464
        return format_registry.get_default()
2158
1465
 
2159
1466
    def get_format_string(self):
2160
1467
        """Return the ASCII format string that identifies this format.
2161
 
        
2162
 
        Note that in pre format ?? repositories the format string is 
 
1468
 
 
1469
        Note that in pre format ?? repositories the format string is
2163
1470
        not permitted nor written to disk.
2164
1471
        """
2165
1472
        raise NotImplementedError(self.get_format_string)
2168
1475
        """Return the short description for this format."""
2169
1476
        raise NotImplementedError(self.get_format_description)
2170
1477
 
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
1478
    def initialize(self, a_bzrdir, shared=False):
2194
1479
        """Initialize a repository of this format in a_bzrdir.
2195
1480
 
2196
1481
        :param a_bzrdir: The bzrdir to put the new repository in it.
2197
1482
        :param shared: The repository should be initialized as a sharable one.
2198
1483
        :returns: The new repository object.
2199
 
        
 
1484
 
2200
1485
        This may raise UninitializableFormat if shared repository are not
2201
1486
        compatible the a_bzrdir.
2202
1487
        """
2206
1491
        """Is this format supported?
2207
1492
 
2208
1493
        Supported formats must be initializable and openable.
2209
 
        Unsupported formats may not support initialization or committing or 
 
1494
        Unsupported formats may not support initialization or committing or
2210
1495
        some other features depending on the reason for not being supported.
2211
1496
        """
2212
1497
        return True
2213
1498
 
 
1499
    def is_deprecated(self):
 
1500
        """Is this format deprecated?
 
1501
 
 
1502
        Deprecated formats may trigger a user-visible warning recommending
 
1503
        the user to upgrade. They are still fully supported.
 
1504
        """
 
1505
        return False
 
1506
 
 
1507
    def network_name(self):
 
1508
        """A simple byte string uniquely identifying this format for RPC calls.
 
1509
 
 
1510
        MetaDir repository formats use their disk format string to identify the
 
1511
        repository over the wire. All in one formats such as bzr < 0.8, and
 
1512
        foreign formats like svn/git and hg should use some marker which is
 
1513
        unique and immutable.
 
1514
        """
 
1515
        raise NotImplementedError(self.network_name)
 
1516
 
2214
1517
    def check_conversion_target(self, target_format):
2215
 
        raise NotImplementedError(self.check_conversion_target)
 
1518
        if self.rich_root_data and not target_format.rich_root_data:
 
1519
            raise errors.BadConversionTarget(
 
1520
                'Does not support rich root data.', target_format,
 
1521
                from_format=self)
 
1522
        if (self.supports_tree_reference and 
 
1523
            not getattr(target_format, 'supports_tree_reference', False)):
 
1524
            raise errors.BadConversionTarget(
 
1525
                'Does not support nested trees', target_format,
 
1526
                from_format=self)
2216
1527
 
2217
1528
    def open(self, a_bzrdir, _found=False):
2218
1529
        """Return an instance of this format for the bzrdir a_bzrdir.
2219
 
        
 
1530
 
2220
1531
        _found is a private parameter, do not use it.
2221
1532
        """
2222
1533
        raise NotImplementedError(self.open)
2223
1534
 
 
1535
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
 
1536
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
 
1537
        hooks = BzrDir.hooks['post_repo_init']
 
1538
        if not hooks:
 
1539
            return
 
1540
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
 
1541
        for hook in hooks:
 
1542
            hook(params)
 
1543
 
2224
1544
 
2225
1545
class MetaDirRepositoryFormat(RepositoryFormat):
2226
1546
    """Common base class for the new repositories using the metadir layout."""
2228
1548
    rich_root_data = False
2229
1549
    supports_tree_reference = False
2230
1550
    supports_external_lookups = False
2231
 
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1551
    supports_leaving_lock = True
 
1552
 
 
1553
    @property
 
1554
    def _matchingbzrdir(self):
 
1555
        matching = bzrdir.BzrDirMetaFormat1()
 
1556
        matching.repository_format = self
 
1557
        return matching
2232
1558
 
2233
1559
    def __init__(self):
2234
1560
        super(MetaDirRepositoryFormat, self).__init__()
2261
1587
        finally:
2262
1588
            control_files.unlock()
2263
1589
 
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
 
1590
    def network_name(self):
 
1591
        """Metadir formats have matching disk and network format strings."""
 
1592
        return self.get_format_string()
 
1593
 
 
1594
 
 
1595
# formats which have no format string are not discoverable or independently
 
1596
# creatable on disk, so are not registered in format_registry.  They're
 
1597
# all in bzrlib.repofmt.knitreponow.  When an instance of one of these is
2268
1598
# needed, it's constructed directly by the BzrDir.  Non-native formats where
2269
1599
# the repository is not separately opened are similar.
2270
1600
 
2271
1601
format_registry.register_lazy(
2272
 
    'Bazaar-NG Repository format 7',
2273
 
    'bzrlib.repofmt.weaverepo',
2274
 
    'RepositoryFormat7'
2275
 
    )
2276
 
 
2277
 
format_registry.register_lazy(
2278
1602
    'Bazaar-NG Knit Repository Format 1',
2279
1603
    'bzrlib.repofmt.knitrepo',
2280
1604
    'RepositoryFormatKnit1',
2297
1621
# NOTE: These are experimental in 0.92. Stable in 1.0 and above
2298
1622
format_registry.register_lazy(
2299
1623
    'Bazaar pack repository format 1 (needs bzr 0.92)\n',
2300
 
    'bzrlib.repofmt.pack_repo',
 
1624
    'bzrlib.repofmt.knitpack_repo',
2301
1625
    'RepositoryFormatKnitPack1',
2302
1626
    )
2303
1627
format_registry.register_lazy(
2304
1628
    'Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n',
2305
 
    'bzrlib.repofmt.pack_repo',
 
1629
    'bzrlib.repofmt.knitpack_repo',
2306
1630
    'RepositoryFormatKnitPack3',
2307
1631
    )
2308
1632
format_registry.register_lazy(
2309
1633
    'Bazaar pack repository format 1 with rich root (needs bzr 1.0)\n',
2310
 
    'bzrlib.repofmt.pack_repo',
 
1634
    'bzrlib.repofmt.knitpack_repo',
2311
1635
    'RepositoryFormatKnitPack4',
2312
1636
    )
2313
1637
format_registry.register_lazy(
2314
1638
    'Bazaar RepositoryFormatKnitPack5 (bzr 1.6)\n',
2315
 
    'bzrlib.repofmt.pack_repo',
 
1639
    'bzrlib.repofmt.knitpack_repo',
2316
1640
    'RepositoryFormatKnitPack5',
2317
1641
    )
2318
1642
format_registry.register_lazy(
2319
1643
    'Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n',
2320
 
    'bzrlib.repofmt.pack_repo',
 
1644
    'bzrlib.repofmt.knitpack_repo',
2321
1645
    'RepositoryFormatKnitPack5RichRoot',
2322
1646
    )
2323
1647
format_registry.register_lazy(
2324
1648
    'Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n',
2325
 
    'bzrlib.repofmt.pack_repo',
 
1649
    'bzrlib.repofmt.knitpack_repo',
2326
1650
    'RepositoryFormatKnitPack5RichRootBroken',
2327
1651
    )
 
1652
format_registry.register_lazy(
 
1653
    'Bazaar RepositoryFormatKnitPack6 (bzr 1.9)\n',
 
1654
    'bzrlib.repofmt.knitpack_repo',
 
1655
    'RepositoryFormatKnitPack6',
 
1656
    )
 
1657
format_registry.register_lazy(
 
1658
    'Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n',
 
1659
    'bzrlib.repofmt.knitpack_repo',
 
1660
    'RepositoryFormatKnitPack6RichRoot',
 
1661
    )
 
1662
format_registry.register_lazy(
 
1663
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
 
1664
    'bzrlib.repofmt.groupcompress_repo',
 
1665
    'RepositoryFormat2a',
 
1666
    )
2328
1667
 
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
 
    )
 
1668
# Development formats.
 
1669
# Check their docstrings to see if/when they are obsolete.
2336
1670
format_registry.register_lazy(
2337
1671
    ("Bazaar development format 2 with subtree support "
2338
1672
        "(needs bzr.dev from before 1.8)\n"),
2339
 
    'bzrlib.repofmt.pack_repo',
 
1673
    'bzrlib.repofmt.knitpack_repo',
2340
1674
    'RepositoryFormatPackDevelopment2Subtree',
2341
1675
    )
 
1676
format_registry.register_lazy(
 
1677
    'Bazaar development format 8\n',
 
1678
    'bzrlib.repofmt.groupcompress_repo',
 
1679
    'RepositoryFormat2aSubtree',
 
1680
    )
2342
1681
 
2343
1682
 
2344
1683
class InterRepository(InterObject):
2345
1684
    """This class represents operations taking place between two repositories.
2346
1685
 
2347
1686
    Its instances have methods like copy_content and fetch, and contain
2348
 
    references to the source and target repositories these operations can be 
 
1687
    references to the source and target repositories these operations can be
2349
1688
    carried out on.
2350
1689
 
2351
1690
    Often we will provide convenience methods on 'repository' which carry out
2356
1695
    _optimisers = []
2357
1696
    """The available optimised InterRepository types."""
2358
1697
 
 
1698
    @needs_write_lock
2359
1699
    def copy_content(self, revision_id=None):
2360
 
        raise NotImplementedError(self.copy_content)
2361
 
 
2362
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
1700
        """Make a complete copy of the content in self into destination.
 
1701
 
 
1702
        This is a destructive operation! Do not use it on existing
 
1703
        repositories.
 
1704
 
 
1705
        :param revision_id: Only copy the content needed to construct
 
1706
                            revision_id and its parents.
 
1707
        """
 
1708
        try:
 
1709
            self.target.set_make_working_trees(self.source.make_working_trees())
 
1710
        except NotImplementedError:
 
1711
            pass
 
1712
        self.target.fetch(self.source, revision_id=revision_id)
 
1713
 
 
1714
    @needs_write_lock
 
1715
    def fetch(self, revision_id=None, find_ghosts=False,
 
1716
            fetch_spec=None):
2363
1717
        """Fetch the content required to construct revision_id.
2364
1718
 
2365
1719
        The content is copied from self.source to self.target.
2366
1720
 
2367
1721
        :param revision_id: if None all content is copied, if NULL_REVISION no
2368
1722
                            content is copied.
2369
 
        :param pb: optional progress bar to use for progress reports. If not
2370
 
                   provided a default one will be created.
2371
 
 
2372
 
        :returns: (copied_revision_count, failures).
2373
 
        """
2374
 
        # Normally we should find a specific InterRepository subclass to do
2375
 
        # the fetch; if nothing else then at least InterSameDataRepository.
2376
 
        # If none of them is suitable it looks like fetching is not possible;
2377
 
        # we try to give a good message why.  _assert_same_model will probably
2378
 
        # give a helpful message; otherwise a generic one.
2379
 
        self._assert_same_model(self.source, self.target)
2380
 
        raise errors.IncompatibleRepositories(self.source, self.target,
2381
 
            "no suitableInterRepository found")
2382
 
 
2383
 
    def _walk_to_common_revisions(self, revision_ids):
2384
 
        """Walk out from revision_ids in source to revisions target has.
2385
 
 
2386
 
        :param revision_ids: The start point for the search.
2387
 
        :return: A set of revision ids.
2388
 
        """
2389
 
        target_graph = self.target.get_graph()
2390
 
        revision_ids = frozenset(revision_ids)
2391
 
        if set(target_graph.get_parent_map(revision_ids)) == revision_ids:
2392
 
            return graph.SearchResult(revision_ids, set(), 0, set())
2393
 
        missing_revs = set()
2394
 
        source_graph = self.source.get_graph()
2395
 
        # ensure we don't pay silly lookup costs.
2396
 
        searcher = source_graph._make_breadth_first_searcher(revision_ids)
2397
 
        null_set = frozenset([_mod_revision.NULL_REVISION])
2398
 
        while True:
2399
 
            try:
2400
 
                next_revs, ghosts = searcher.next_with_ghosts()
2401
 
            except StopIteration:
2402
 
                break
2403
 
            if revision_ids.intersection(ghosts):
2404
 
                absent_ids = set(revision_ids.intersection(ghosts))
2405
 
                # If all absent_ids are present in target, no error is needed.
2406
 
                absent_ids.difference_update(
2407
 
                    set(target_graph.get_parent_map(absent_ids)))
2408
 
                if absent_ids:
2409
 
                    raise errors.NoSuchRevision(self.source, absent_ids.pop())
2410
 
            # we don't care about other ghosts as we can't fetch them and
2411
 
            # haven't been asked to.
2412
 
            next_revs = set(next_revs)
2413
 
            # we always have NULL_REVISION present.
2414
 
            have_revs = set(target_graph.get_parent_map(next_revs)).union(null_set)
2415
 
            missing_revs.update(next_revs - have_revs)
2416
 
            searcher.stop_searching_any(have_revs)
2417
 
        return searcher.get_result()
2418
 
   
2419
 
    @deprecated_method(one_two)
2420
 
    @needs_read_lock
2421
 
    def missing_revision_ids(self, revision_id=None, find_ghosts=True):
2422
 
        """Return the revision ids that source has that target does not.
2423
 
        
2424
 
        These are returned in topological order.
2425
 
 
2426
 
        :param revision_id: only return revision ids included by this
2427
 
                            revision_id.
2428
 
        :param find_ghosts: If True find missing revisions in deep history
2429
 
            rather than just finding the surface difference.
2430
 
        """
2431
 
        return list(self.search_missing_revision_ids(
2432
 
            revision_id, find_ghosts).get_keys())
2433
 
 
2434
 
    @needs_read_lock
2435
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2436
 
        """Return the revision ids that source has that target does not.
2437
 
        
2438
 
        :param revision_id: only return revision ids included by this
2439
 
                            revision_id.
2440
 
        :param find_ghosts: If True find missing revisions in deep history
2441
 
            rather than just finding the surface difference.
 
1723
        :return: None.
 
1724
        """
 
1725
        raise NotImplementedError(self.fetch)
 
1726
 
 
1727
    @needs_read_lock
 
1728
    def search_missing_revision_ids(self,
 
1729
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
 
1730
            find_ghosts=True, revision_ids=None, if_present_ids=None,
 
1731
            limit=None):
 
1732
        """Return the revision ids that source has that target does not.
 
1733
 
 
1734
        :param revision_id: only return revision ids included by this
 
1735
            revision_id.
 
1736
        :param revision_ids: return revision ids included by these
 
1737
            revision_ids.  NoSuchRevision will be raised if any of these
 
1738
            revisions are not present.
 
1739
        :param if_present_ids: like revision_ids, but will not cause
 
1740
            NoSuchRevision if any of these are absent, instead they will simply
 
1741
            not be in the result.  This is useful for e.g. finding revisions
 
1742
            to fetch for tags, which may reference absent revisions.
 
1743
        :param find_ghosts: If True find missing revisions in deep history
 
1744
            rather than just finding the surface difference.
 
1745
        :param limit: Maximum number of revisions to return, topologically
 
1746
            ordered
2442
1747
        :return: A bzrlib.graph.SearchResult.
2443
1748
        """
2444
 
        # stop searching at found target revisions.
2445
 
        if not find_ghosts and revision_id is not None:
2446
 
            return self._walk_to_common_revisions([revision_id])
2447
 
        # generic, possibly worst case, slow code path.
2448
 
        target_ids = set(self.target.all_revision_ids())
2449
 
        if revision_id is not None:
2450
 
            source_ids = self.source.get_ancestry(revision_id)
2451
 
            if source_ids[0] is not None:
2452
 
                raise AssertionError()
2453
 
            source_ids.pop(0)
2454
 
        else:
2455
 
            source_ids = self.source.all_revision_ids()
2456
 
        result_set = set(source_ids).difference(target_ids)
2457
 
        return self.source.revision_ids_to_search_result(result_set)
 
1749
        raise NotImplementedError(self.search_missing_revision_ids)
2458
1750
 
2459
1751
    @staticmethod
2460
1752
    def _same_model(source, target):
2461
1753
        """True if source and target have the same data representation.
2462
 
        
 
1754
 
2463
1755
        Note: this is always called on the base class; overriding it in a
2464
1756
        subclass will have no effect.
2465
1757
        """
2481
1773
                "different serializers")
2482
1774
 
2483
1775
 
2484
 
class InterSameDataRepository(InterRepository):
2485
 
    """Code for converting between repositories that represent the same data.
2486
 
    
2487
 
    Data format and model must match for this to work.
2488
 
    """
2489
 
 
2490
 
    @classmethod
2491
 
    def _get_repo_format_to_test(self):
2492
 
        """Repository format for testing with.
2493
 
        
2494
 
        InterSameData can pull from subtree to subtree and from non-subtree to
2495
 
        non-subtree, so we test this with the richest repository format.
2496
 
        """
2497
 
        from bzrlib.repofmt import knitrepo
2498
 
        return knitrepo.RepositoryFormatKnit3()
2499
 
 
2500
 
    @staticmethod
2501
 
    def is_compatible(source, target):
2502
 
        return InterRepository._same_model(source, target)
2503
 
 
2504
 
    @needs_write_lock
2505
 
    def copy_content(self, revision_id=None):
2506
 
        """Make a complete copy of the content in self into destination.
2507
 
 
2508
 
        This copies both the repository's revision data, and configuration information
2509
 
        such as the make_working_trees setting.
2510
 
        
2511
 
        This is a destructive operation! Do not use it on existing 
2512
 
        repositories.
2513
 
 
2514
 
        :param revision_id: Only copy the content needed to construct
2515
 
                            revision_id and its parents.
2516
 
        """
2517
 
        try:
2518
 
            self.target.set_make_working_trees(self.source.make_working_trees())
2519
 
        except NotImplementedError:
2520
 
            pass
2521
 
        # but don't bother fetching if we have the needed data now.
2522
 
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
2523
 
            self.target.has_revision(revision_id)):
2524
 
            return
2525
 
        self.target.fetch(self.source, revision_id=revision_id)
2526
 
 
2527
 
    @needs_write_lock
2528
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2529
 
        """See InterRepository.fetch()."""
2530
 
        from bzrlib.fetch import RepoFetcher
2531
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2532
 
               self.source, self.source._format, self.target,
2533
 
               self.target._format)
2534
 
        f = RepoFetcher(to_repository=self.target,
2535
 
                               from_repository=self.source,
2536
 
                               last_revision=revision_id,
2537
 
                               pb=pb, find_ghosts=find_ghosts)
2538
 
        return f.count_copied, f.failed_revisions
2539
 
 
2540
 
 
2541
 
class InterWeaveRepo(InterSameDataRepository):
2542
 
    """Optimised code paths between Weave based repositories.
2543
 
    
2544
 
    This should be in bzrlib/repofmt/weaverepo.py but we have not yet
2545
 
    implemented lazy inter-object optimisation.
2546
 
    """
2547
 
 
2548
 
    @classmethod
2549
 
    def _get_repo_format_to_test(self):
2550
 
        from bzrlib.repofmt import weaverepo
2551
 
        return weaverepo.RepositoryFormat7()
2552
 
 
2553
 
    @staticmethod
2554
 
    def is_compatible(source, target):
2555
 
        """Be compatible with known Weave formats.
2556
 
        
2557
 
        We don't test for the stores being of specific types because that
2558
 
        could lead to confusing results, and there is no need to be 
2559
 
        overly general.
2560
 
        """
2561
 
        from bzrlib.repofmt.weaverepo import (
2562
 
                RepositoryFormat5,
2563
 
                RepositoryFormat6,
2564
 
                RepositoryFormat7,
2565
 
                )
2566
 
        try:
2567
 
            return (isinstance(source._format, (RepositoryFormat5,
2568
 
                                                RepositoryFormat6,
2569
 
                                                RepositoryFormat7)) and
2570
 
                    isinstance(target._format, (RepositoryFormat5,
2571
 
                                                RepositoryFormat6,
2572
 
                                                RepositoryFormat7)))
2573
 
        except AttributeError:
2574
 
            return False
2575
 
    
2576
 
    @needs_write_lock
2577
 
    def copy_content(self, revision_id=None):
2578
 
        """See InterRepository.copy_content()."""
2579
 
        # weave specific optimised path:
2580
 
        try:
2581
 
            self.target.set_make_working_trees(self.source.make_working_trees())
2582
 
        except (errors.RepositoryUpgradeRequired, NotImplemented):
2583
 
            pass
2584
 
        # FIXME do not peek!
2585
 
        if self.source._transport.listable():
2586
 
            pb = ui.ui_factory.nested_progress_bar()
2587
 
            try:
2588
 
                self.target.texts.insert_record_stream(
2589
 
                    self.source.texts.get_record_stream(
2590
 
                        self.source.texts.keys(), 'topological', False))
2591
 
                pb.update('copying inventory', 0, 1)
2592
 
                self.target.inventories.insert_record_stream(
2593
 
                    self.source.inventories.get_record_stream(
2594
 
                        self.source.inventories.keys(), 'topological', False))
2595
 
                self.target.signatures.insert_record_stream(
2596
 
                    self.source.signatures.get_record_stream(
2597
 
                        self.source.signatures.keys(),
2598
 
                        'unordered', True))
2599
 
                self.target.revisions.insert_record_stream(
2600
 
                    self.source.revisions.get_record_stream(
2601
 
                        self.source.revisions.keys(),
2602
 
                        'topological', True))
2603
 
            finally:
2604
 
                pb.finished()
2605
 
        else:
2606
 
            self.target.fetch(self.source, revision_id=revision_id)
2607
 
 
2608
 
    @needs_write_lock
2609
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2610
 
        """See InterRepository.fetch()."""
2611
 
        from bzrlib.fetch import RepoFetcher
2612
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2613
 
               self.source, self.source._format, self.target, self.target._format)
2614
 
        f = RepoFetcher(to_repository=self.target,
2615
 
                               from_repository=self.source,
2616
 
                               last_revision=revision_id,
2617
 
                               pb=pb, find_ghosts=find_ghosts)
2618
 
        return f.count_copied, f.failed_revisions
2619
 
 
2620
 
    @needs_read_lock
2621
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2622
 
        """See InterRepository.missing_revision_ids()."""
2623
 
        # we want all revisions to satisfy revision_id in source.
2624
 
        # but we don't want to stat every file here and there.
2625
 
        # we want then, all revisions other needs to satisfy revision_id 
2626
 
        # checked, but not those that we have locally.
2627
 
        # so the first thing is to get a subset of the revisions to 
2628
 
        # satisfy revision_id in source, and then eliminate those that
2629
 
        # we do already have. 
2630
 
        # this is slow on high latency connection to self, but as as this
2631
 
        # disk format scales terribly for push anyway due to rewriting 
2632
 
        # inventory.weave, this is considered acceptable.
2633
 
        # - RBC 20060209
2634
 
        if revision_id is not None:
2635
 
            source_ids = self.source.get_ancestry(revision_id)
2636
 
            if source_ids[0] is not None:
2637
 
                raise AssertionError()
2638
 
            source_ids.pop(0)
2639
 
        else:
2640
 
            source_ids = self.source._all_possible_ids()
2641
 
        source_ids_set = set(source_ids)
2642
 
        # source_ids is the worst possible case we may need to pull.
2643
 
        # now we want to filter source_ids against what we actually
2644
 
        # have in target, but don't try to check for existence where we know
2645
 
        # we do not have a revision as that would be pointless.
2646
 
        target_ids = set(self.target._all_possible_ids())
2647
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
2648
 
        actually_present_revisions = set(
2649
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
2650
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
2651
 
        if revision_id is not None:
2652
 
            # we used get_ancestry to determine source_ids then we are assured all
2653
 
            # revisions referenced are present as they are installed in topological order.
2654
 
            # and the tip revision was validated by get_ancestry.
2655
 
            result_set = required_revisions
2656
 
        else:
2657
 
            # if we just grabbed the possibly available ids, then 
2658
 
            # we only have an estimate of whats available and need to validate
2659
 
            # that against the revision records.
2660
 
            result_set = set(
2661
 
                self.source._eliminate_revisions_not_present(required_revisions))
2662
 
        return self.source.revision_ids_to_search_result(result_set)
2663
 
 
2664
 
 
2665
 
class InterKnitRepo(InterSameDataRepository):
2666
 
    """Optimised code paths between Knit based repositories."""
2667
 
 
2668
 
    @classmethod
2669
 
    def _get_repo_format_to_test(self):
2670
 
        from bzrlib.repofmt import knitrepo
2671
 
        return knitrepo.RepositoryFormatKnit1()
2672
 
 
2673
 
    @staticmethod
2674
 
    def is_compatible(source, target):
2675
 
        """Be compatible with known Knit formats.
2676
 
        
2677
 
        We don't test for the stores being of specific types because that
2678
 
        could lead to confusing results, and there is no need to be 
2679
 
        overly general.
2680
 
        """
2681
 
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
2682
 
        try:
2683
 
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
2684
 
                isinstance(target._format, RepositoryFormatKnit))
2685
 
        except AttributeError:
2686
 
            return False
2687
 
        return are_knits and InterRepository._same_model(source, target)
2688
 
 
2689
 
    @needs_write_lock
2690
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2691
 
        """See InterRepository.fetch()."""
2692
 
        from bzrlib.fetch import RepoFetcher
2693
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2694
 
               self.source, self.source._format, self.target, self.target._format)
2695
 
        f = RepoFetcher(to_repository=self.target,
2696
 
                            from_repository=self.source,
2697
 
                            last_revision=revision_id,
2698
 
                            pb=pb, find_ghosts=find_ghosts)
2699
 
        return f.count_copied, f.failed_revisions
2700
 
 
2701
 
    @needs_read_lock
2702
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2703
 
        """See InterRepository.missing_revision_ids()."""
2704
 
        if revision_id is not None:
2705
 
            source_ids = self.source.get_ancestry(revision_id)
2706
 
            if source_ids[0] is not None:
2707
 
                raise AssertionError()
2708
 
            source_ids.pop(0)
2709
 
        else:
2710
 
            source_ids = self.source.all_revision_ids()
2711
 
        source_ids_set = set(source_ids)
2712
 
        # source_ids is the worst possible case we may need to pull.
2713
 
        # now we want to filter source_ids against what we actually
2714
 
        # have in target, but don't try to check for existence where we know
2715
 
        # we do not have a revision as that would be pointless.
2716
 
        target_ids = set(self.target.all_revision_ids())
2717
 
        possibly_present_revisions = target_ids.intersection(source_ids_set)
2718
 
        actually_present_revisions = set(
2719
 
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
2720
 
        required_revisions = source_ids_set.difference(actually_present_revisions)
2721
 
        if revision_id is not None:
2722
 
            # we used get_ancestry to determine source_ids then we are assured all
2723
 
            # revisions referenced are present as they are installed in topological order.
2724
 
            # and the tip revision was validated by get_ancestry.
2725
 
            result_set = required_revisions
2726
 
        else:
2727
 
            # if we just grabbed the possibly available ids, then 
2728
 
            # we only have an estimate of whats available and need to validate
2729
 
            # that against the revision records.
2730
 
            result_set = set(
2731
 
                self.source._eliminate_revisions_not_present(required_revisions))
2732
 
        return self.source.revision_ids_to_search_result(result_set)
2733
 
 
2734
 
 
2735
 
class InterPackRepo(InterSameDataRepository):
2736
 
    """Optimised code paths between Pack based repositories."""
2737
 
 
2738
 
    @classmethod
2739
 
    def _get_repo_format_to_test(self):
2740
 
        from bzrlib.repofmt import pack_repo
2741
 
        return pack_repo.RepositoryFormatKnitPack1()
2742
 
 
2743
 
    @staticmethod
2744
 
    def is_compatible(source, target):
2745
 
        """Be compatible with known Pack formats.
2746
 
        
2747
 
        We don't test for the stores being of specific types because that
2748
 
        could lead to confusing results, and there is no need to be 
2749
 
        overly general.
2750
 
        """
2751
 
        from bzrlib.repofmt.pack_repo import RepositoryFormatPack
2752
 
        try:
2753
 
            are_packs = (isinstance(source._format, RepositoryFormatPack) and
2754
 
                isinstance(target._format, RepositoryFormatPack))
2755
 
        except AttributeError:
2756
 
            return False
2757
 
        return are_packs and InterRepository._same_model(source, target)
2758
 
 
2759
 
    @needs_write_lock
2760
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2761
 
        """See InterRepository.fetch()."""
2762
 
        if (len(self.source._fallback_repositories) > 0 or
2763
 
            len(self.target._fallback_repositories) > 0):
2764
 
            # The pack layer is not aware of fallback repositories, so when
2765
 
            # fetching from a stacked repository or into a stacked repository
2766
 
            # we use the generic fetch logic which uses the VersionedFiles
2767
 
            # attributes on repository.
2768
 
            from bzrlib.fetch import RepoFetcher
2769
 
            fetcher = RepoFetcher(self.target, self.source, revision_id,
2770
 
                                  pb, find_ghosts)
2771
 
            return fetcher.count_copied, fetcher.failed_revisions
2772
 
        from bzrlib.repofmt.pack_repo import Packer
2773
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2774
 
               self.source, self.source._format, self.target, self.target._format)
2775
 
        self.count_copied = 0
2776
 
        if revision_id is None:
2777
 
            # TODO:
2778
 
            # everything to do - use pack logic
2779
 
            # to fetch from all packs to one without
2780
 
            # inventory parsing etc, IFF nothing to be copied is in the target.
2781
 
            # till then:
2782
 
            source_revision_ids = frozenset(self.source.all_revision_ids())
2783
 
            revision_ids = source_revision_ids - \
2784
 
                frozenset(self.target.get_parent_map(source_revision_ids))
2785
 
            revision_keys = [(revid,) for revid in revision_ids]
2786
 
            index = self.target._pack_collection.revision_index.combined_index
2787
 
            present_revision_ids = set(item[1][0] for item in
2788
 
                index.iter_entries(revision_keys))
2789
 
            revision_ids = set(revision_ids) - present_revision_ids
2790
 
            # implementing the TODO will involve:
2791
 
            # - detecting when all of a pack is selected
2792
 
            # - avoiding as much as possible pre-selection, so the
2793
 
            # more-core routines such as create_pack_from_packs can filter in
2794
 
            # a just-in-time fashion. (though having a HEADS list on a
2795
 
            # repository might make this a lot easier, because we could
2796
 
            # sensibly detect 'new revisions' without doing a full index scan.
2797
 
        elif _mod_revision.is_null(revision_id):
2798
 
            # nothing to do:
2799
 
            return (0, [])
2800
 
        else:
2801
 
            try:
2802
 
                revision_ids = self.search_missing_revision_ids(revision_id,
2803
 
                    find_ghosts=find_ghosts).get_keys()
2804
 
            except errors.NoSuchRevision:
2805
 
                raise errors.InstallFailed([revision_id])
2806
 
            if len(revision_ids) == 0:
2807
 
                return (0, [])
2808
 
        packs = self.source._pack_collection.all_packs()
2809
 
        pack = Packer(self.target._pack_collection, packs, '.fetch',
2810
 
            revision_ids).pack()
2811
 
        if pack is not None:
2812
 
            self.target._pack_collection._save_pack_names()
2813
 
            # Trigger an autopack. This may duplicate effort as we've just done
2814
 
            # a pack creation, but for now it is simpler to think about as
2815
 
            # 'upload data, then repack if needed'.
2816
 
            self.target._pack_collection.autopack()
2817
 
            return (pack.get_revision_count(), [])
2818
 
        else:
2819
 
            return (0, [])
2820
 
 
2821
 
    @needs_read_lock
2822
 
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2823
 
        """See InterRepository.missing_revision_ids().
2824
 
        
2825
 
        :param find_ghosts: Find ghosts throughout the ancestry of
2826
 
            revision_id.
2827
 
        """
2828
 
        if not find_ghosts and revision_id is not None:
2829
 
            return self._walk_to_common_revisions([revision_id])
2830
 
        elif revision_id is not None:
2831
 
            # Find ghosts: search for revisions pointing from one repository to
2832
 
            # the other, and vice versa, anywhere in the history of revision_id.
2833
 
            graph = self.target.get_graph(other_repository=self.source)
2834
 
            searcher = graph._make_breadth_first_searcher([revision_id])
2835
 
            found_ids = set()
2836
 
            while True:
2837
 
                try:
2838
 
                    next_revs, ghosts = searcher.next_with_ghosts()
2839
 
                except StopIteration:
2840
 
                    break
2841
 
                if revision_id in ghosts:
2842
 
                    raise errors.NoSuchRevision(self.source, revision_id)
2843
 
                found_ids.update(next_revs)
2844
 
                found_ids.update(ghosts)
2845
 
            found_ids = frozenset(found_ids)
2846
 
            # Double query here: should be able to avoid this by changing the
2847
 
            # graph api further.
2848
 
            result_set = found_ids - frozenset(
2849
 
                self.target.get_parent_map(found_ids))
2850
 
        else:
2851
 
            source_ids = self.source.all_revision_ids()
2852
 
            # source_ids is the worst possible case we may need to pull.
2853
 
            # now we want to filter source_ids against what we actually
2854
 
            # have in target, but don't try to check for existence where we know
2855
 
            # we do not have a revision as that would be pointless.
2856
 
            target_ids = set(self.target.all_revision_ids())
2857
 
            result_set = set(source_ids).difference(target_ids)
2858
 
        return self.source.revision_ids_to_search_result(result_set)
2859
 
 
2860
 
 
2861
 
class InterModel1and2(InterRepository):
2862
 
 
2863
 
    @classmethod
2864
 
    def _get_repo_format_to_test(self):
2865
 
        return None
2866
 
 
2867
 
    @staticmethod
2868
 
    def is_compatible(source, target):
2869
 
        if not source.supports_rich_root() and target.supports_rich_root():
2870
 
            return True
2871
 
        else:
2872
 
            return False
2873
 
 
2874
 
    @needs_write_lock
2875
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2876
 
        """See InterRepository.fetch()."""
2877
 
        from bzrlib.fetch import Model1toKnit2Fetcher
2878
 
        f = Model1toKnit2Fetcher(to_repository=self.target,
2879
 
                                 from_repository=self.source,
2880
 
                                 last_revision=revision_id,
2881
 
                                 pb=pb, find_ghosts=find_ghosts)
2882
 
        return f.count_copied, f.failed_revisions
2883
 
 
2884
 
    @needs_write_lock
2885
 
    def copy_content(self, revision_id=None):
2886
 
        """Make a complete copy of the content in self into destination.
2887
 
        
2888
 
        This is a destructive operation! Do not use it on existing 
2889
 
        repositories.
2890
 
 
2891
 
        :param revision_id: Only copy the content needed to construct
2892
 
                            revision_id and its parents.
2893
 
        """
2894
 
        try:
2895
 
            self.target.set_make_working_trees(self.source.make_working_trees())
2896
 
        except NotImplementedError:
2897
 
            pass
2898
 
        # but don't bother fetching if we have the needed data now.
2899
 
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
2900
 
            self.target.has_revision(revision_id)):
2901
 
            return
2902
 
        self.target.fetch(self.source, revision_id=revision_id)
2903
 
 
2904
 
 
2905
 
class InterKnit1and2(InterKnitRepo):
2906
 
 
2907
 
    @classmethod
2908
 
    def _get_repo_format_to_test(self):
2909
 
        return None
2910
 
 
2911
 
    @staticmethod
2912
 
    def is_compatible(source, target):
2913
 
        """Be compatible with Knit1 source and Knit3 target"""
2914
 
        try:
2915
 
            from bzrlib.repofmt.knitrepo import (
2916
 
                RepositoryFormatKnit1,
2917
 
                RepositoryFormatKnit3,
2918
 
                )
2919
 
            from bzrlib.repofmt.pack_repo import (
2920
 
                RepositoryFormatKnitPack1,
2921
 
                RepositoryFormatKnitPack3,
2922
 
                RepositoryFormatKnitPack4,
2923
 
                RepositoryFormatKnitPack5,
2924
 
                RepositoryFormatKnitPack5RichRoot,
2925
 
                RepositoryFormatPackDevelopment2,
2926
 
                RepositoryFormatPackDevelopment2Subtree,
2927
 
                )
2928
 
            norichroot = (
2929
 
                RepositoryFormatKnit1,            # no rr, no subtree
2930
 
                RepositoryFormatKnitPack1,        # no rr, no subtree
2931
 
                RepositoryFormatPackDevelopment2, # no rr, no subtree
2932
 
                RepositoryFormatKnitPack5,        # no rr, no subtree
2933
 
                )
2934
 
            richroot = (
2935
 
                RepositoryFormatKnit3,            # rr, subtree
2936
 
                RepositoryFormatKnitPack3,        # rr, subtree
2937
 
                RepositoryFormatKnitPack4,        # rr, no subtree
2938
 
                RepositoryFormatKnitPack5RichRoot,# rr, no subtree
2939
 
                RepositoryFormatPackDevelopment2Subtree, # rr, subtree
2940
 
                )
2941
 
            for format in norichroot:
2942
 
                if format.rich_root_data:
2943
 
                    raise AssertionError('Format %s is a rich-root format'
2944
 
                        ' but is included in the non-rich-root list'
2945
 
                        % (format,))
2946
 
            for format in richroot:
2947
 
                if not format.rich_root_data:
2948
 
                    raise AssertionError('Format %s is not a rich-root format'
2949
 
                        ' but is included in the rich-root list'
2950
 
                        % (format,))
2951
 
            # TODO: One alternative is to just check format.rich_root_data,
2952
 
            #       instead of keeping membership lists. However, the formats
2953
 
            #       *also* have to use the same 'Knit' style of storage
2954
 
            #       (line-deltas, fulltexts, etc.)
2955
 
            return (isinstance(source._format, norichroot) and
2956
 
                    isinstance(target._format, richroot))
2957
 
        except AttributeError:
2958
 
            return False
2959
 
 
2960
 
    @needs_write_lock
2961
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2962
 
        """See InterRepository.fetch()."""
2963
 
        from bzrlib.fetch import Knit1to2Fetcher
2964
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2965
 
               self.source, self.source._format, self.target, 
2966
 
               self.target._format)
2967
 
        f = Knit1to2Fetcher(to_repository=self.target,
2968
 
                            from_repository=self.source,
2969
 
                            last_revision=revision_id,
2970
 
                            pb=pb, find_ghosts=find_ghosts)
2971
 
        return f.count_copied, f.failed_revisions
2972
 
 
2973
 
 
2974
 
class InterDifferingSerializer(InterKnitRepo):
2975
 
 
2976
 
    @classmethod
2977
 
    def _get_repo_format_to_test(self):
2978
 
        return None
2979
 
 
2980
 
    @staticmethod
2981
 
    def is_compatible(source, target):
2982
 
        """Be compatible with Knit2 source and Knit3 target"""
2983
 
        if source.supports_rich_root() != target.supports_rich_root():
2984
 
            return False
2985
 
        # Ideally, we'd support fetching if the source had no tree references
2986
 
        # even if it supported them...
2987
 
        if (getattr(source, '_format.supports_tree_reference', False) and
2988
 
            not getattr(target, '_format.supports_tree_reference', False)):
2989
 
            return False
2990
 
        return True
2991
 
 
2992
 
    @needs_write_lock
2993
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2994
 
        """See InterRepository.fetch()."""
2995
 
        revision_ids = self.target.search_missing_revision_ids(self.source,
2996
 
            revision_id, find_ghosts=find_ghosts).get_keys()
2997
 
        revision_ids = tsort.topo_sort(
2998
 
            self.source.get_graph().get_parent_map(revision_ids))
2999
 
        def revisions_iterator():
3000
 
            for current_revision_id in revision_ids:
3001
 
                revision = self.source.get_revision(current_revision_id)
3002
 
                tree = self.source.revision_tree(current_revision_id)
3003
 
                try:
3004
 
                    signature = self.source.get_signature_text(
3005
 
                        current_revision_id)
3006
 
                except errors.NoSuchRevision:
3007
 
                    signature = None
3008
 
                yield revision, tree, signature
3009
 
        if pb is None:
3010
 
            my_pb = ui.ui_factory.nested_progress_bar()
3011
 
            pb = my_pb
3012
 
        else:
3013
 
            my_pb = None
3014
 
        try:
3015
 
            install_revisions(self.target, revisions_iterator(),
3016
 
                              len(revision_ids), pb)
3017
 
        finally:
3018
 
            if my_pb is not None:
3019
 
                my_pb.finished()
3020
 
        return len(revision_ids), 0
3021
 
 
3022
 
 
3023
 
class InterOtherToRemote(InterRepository):
3024
 
 
3025
 
    def __init__(self, source, target):
3026
 
        InterRepository.__init__(self, source, target)
3027
 
        self._real_inter = None
3028
 
 
3029
 
    @staticmethod
3030
 
    def is_compatible(source, target):
3031
 
        if isinstance(target, remote.RemoteRepository):
3032
 
            return True
3033
 
        return False
3034
 
 
3035
 
    def _ensure_real_inter(self):
3036
 
        if self._real_inter is None:
3037
 
            self.target._ensure_real()
3038
 
            real_target = self.target._real_repository
3039
 
            self._real_inter = InterRepository.get(self.source, real_target)
3040
 
    
3041
 
    def copy_content(self, revision_id=None):
3042
 
        self._ensure_real_inter()
3043
 
        self._real_inter.copy_content(revision_id=revision_id)
3044
 
 
3045
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
3046
 
        self._ensure_real_inter()
3047
 
        return self._real_inter.fetch(revision_id=revision_id, pb=pb,
3048
 
            find_ghosts=find_ghosts)
3049
 
 
3050
 
    @classmethod
3051
 
    def _get_repo_format_to_test(self):
3052
 
        return None
3053
 
 
3054
 
 
3055
 
class InterRemoteToOther(InterRepository):
3056
 
 
3057
 
    def __init__(self, source, target):
3058
 
        InterRepository.__init__(self, source, target)
3059
 
        self._real_inter = None
3060
 
 
3061
 
    @staticmethod
3062
 
    def is_compatible(source, target):
3063
 
        if not isinstance(source, remote.RemoteRepository):
3064
 
            return False
3065
 
        # Is source's model compatible with target's model?
3066
 
        source._ensure_real()
3067
 
        real_source = source._real_repository
3068
 
        if isinstance(real_source, remote.RemoteRepository):
3069
 
            raise NotImplementedError(
3070
 
                "We don't support remote repos backed by remote repos yet.")
3071
 
        return InterRepository._same_model(real_source, target)
3072
 
 
3073
 
    def _ensure_real_inter(self):
3074
 
        if self._real_inter is None:
3075
 
            self.source._ensure_real()
3076
 
            real_source = self.source._real_repository
3077
 
            self._real_inter = InterRepository.get(real_source, self.target)
3078
 
    
3079
 
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
3080
 
        self._ensure_real_inter()
3081
 
        return self._real_inter.fetch(revision_id=revision_id, pb=pb,
3082
 
            find_ghosts=find_ghosts)
3083
 
 
3084
 
    def copy_content(self, revision_id=None):
3085
 
        self._ensure_real_inter()
3086
 
        self._real_inter.copy_content(revision_id=revision_id)
3087
 
 
3088
 
    @classmethod
3089
 
    def _get_repo_format_to_test(self):
3090
 
        return None
3091
 
 
3092
 
 
3093
 
 
3094
 
InterRepository.register_optimiser(InterDifferingSerializer)
3095
 
InterRepository.register_optimiser(InterSameDataRepository)
3096
 
InterRepository.register_optimiser(InterWeaveRepo)
3097
 
InterRepository.register_optimiser(InterKnitRepo)
3098
 
InterRepository.register_optimiser(InterModel1and2)
3099
 
InterRepository.register_optimiser(InterKnit1and2)
3100
 
InterRepository.register_optimiser(InterPackRepo)
3101
 
InterRepository.register_optimiser(InterOtherToRemote)
3102
 
InterRepository.register_optimiser(InterRemoteToOther)
3103
 
 
3104
 
 
3105
1776
class CopyConverter(object):
3106
1777
    """A repository conversion tool which just performs a copy of the content.
3107
 
    
 
1778
 
3108
1779
    This is slow but quite reliable.
3109
1780
    """
3110
1781
 
3114
1785
        :param target_format: The format the resulting repository should be.
3115
1786
        """
3116
1787
        self.target_format = target_format
3117
 
        
 
1788
 
3118
1789
    def convert(self, repo, pb):
3119
1790
        """Perform the conversion of to_convert, giving feedback via pb.
3120
1791
 
3121
1792
        :param to_convert: The disk object to convert.
3122
1793
        :param pb: a progress bar to use for progress information.
3123
1794
        """
3124
 
        self.pb = pb
 
1795
        pb = ui.ui_factory.nested_progress_bar()
3125
1796
        self.count = 0
3126
1797
        self.total = 4
3127
1798
        # this is only useful with metadir layouts - separated repo content.
3128
1799
        # trigger an assertion if not such
3129
1800
        repo._format.get_format_string()
3130
1801
        self.repo_dir = repo.bzrdir
3131
 
        self.step('Moving repository to repository.backup')
 
1802
        pb.update('Moving repository to repository.backup')
3132
1803
        self.repo_dir.transport.move('repository', 'repository.backup')
3133
1804
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
3134
1805
        repo._format.check_conversion_target(self.target_format)
3135
1806
        self.source_repo = repo._format.open(self.repo_dir,
3136
1807
            _found=True,
3137
1808
            _override_transport=backup_transport)
3138
 
        self.step('Creating new repository')
 
1809
        pb.update('Creating new repository')
3139
1810
        converted = self.target_format.initialize(self.repo_dir,
3140
1811
                                                  self.source_repo.is_shared())
3141
1812
        converted.lock_write()
3142
1813
        try:
3143
 
            self.step('Copying content into repository.')
 
1814
            pb.update('Copying content')
3144
1815
            self.source_repo.copy_content_into(converted)
3145
1816
        finally:
3146
1817
            converted.unlock()
3147
 
        self.step('Deleting old repository content.')
 
1818
        pb.update('Deleting old repository content')
3148
1819
        self.repo_dir.transport.delete_tree('repository.backup')
3149
 
        self.pb.note('repository converted')
3150
 
 
3151
 
    def step(self, message):
3152
 
        """Update the pb by a step."""
3153
 
        self.count +=1
3154
 
        self.pb.update(message, self.count, self.total)
3155
 
 
3156
 
 
3157
 
_unescape_map = {
3158
 
    'apos':"'",
3159
 
    'quot':'"',
3160
 
    'amp':'&',
3161
 
    'lt':'<',
3162
 
    'gt':'>'
3163
 
}
3164
 
 
3165
 
 
3166
 
def _unescaper(match, _map=_unescape_map):
3167
 
    code = match.group(1)
3168
 
    try:
3169
 
        return _map[code]
3170
 
    except KeyError:
3171
 
        if not code.startswith('#'):
3172
 
            raise
3173
 
        return unichr(int(code[1:])).encode('utf8')
3174
 
 
3175
 
 
3176
 
_unescape_re = None
3177
 
 
3178
 
 
3179
 
def _unescape_xml(data):
3180
 
    """Unescape predefined XML entities in a string of data."""
3181
 
    global _unescape_re
3182
 
    if _unescape_re is None:
3183
 
        _unescape_re = re.compile('\&([^;]*);')
3184
 
    return _unescape_re.sub(_unescaper, data)
3185
 
 
3186
 
 
3187
 
class _VersionedFileChecker(object):
3188
 
 
3189
 
    def __init__(self, repository):
3190
 
        self.repository = repository
3191
 
        self.text_index = self.repository._generate_text_key_index()
3192
 
    
3193
 
    def calculate_file_version_parents(self, text_key):
3194
 
        """Calculate the correct parents for a file version according to
3195
 
        the inventories.
3196
 
        """
3197
 
        parent_keys = self.text_index[text_key]
3198
 
        if parent_keys == [_mod_revision.NULL_REVISION]:
3199
 
            return ()
3200
 
        return tuple(parent_keys)
3201
 
 
3202
 
    def check_file_version_parents(self, texts, progress_bar=None):
3203
 
        """Check the parents stored in a versioned file are correct.
3204
 
 
3205
 
        It also detects file versions that are not referenced by their
3206
 
        corresponding revision's inventory.
3207
 
 
3208
 
        :returns: A tuple of (wrong_parents, dangling_file_versions).
3209
 
            wrong_parents is a dict mapping {revision_id: (stored_parents,
3210
 
            correct_parents)} for each revision_id where the stored parents
3211
 
            are not correct.  dangling_file_versions is a set of (file_id,
3212
 
            revision_id) tuples for versions that are present in this versioned
3213
 
            file, but not used by the corresponding inventory.
3214
 
        """
3215
 
        wrong_parents = {}
3216
 
        self.file_ids = set([file_id for file_id, _ in
3217
 
            self.text_index.iterkeys()])
3218
 
        # text keys is now grouped by file_id
3219
 
        n_weaves = len(self.file_ids)
3220
 
        files_in_revisions = {}
3221
 
        revisions_of_files = {}
3222
 
        n_versions = len(self.text_index)
3223
 
        progress_bar.update('loading text store', 0, n_versions)
3224
 
        parent_map = self.repository.texts.get_parent_map(self.text_index)
3225
 
        # On unlistable transports this could well be empty/error...
3226
 
        text_keys = self.repository.texts.keys()
3227
 
        unused_keys = frozenset(text_keys) - set(self.text_index)
3228
 
        for num, key in enumerate(self.text_index.iterkeys()):
3229
 
            if progress_bar is not None:
3230
 
                progress_bar.update('checking text graph', num, n_versions)
3231
 
            correct_parents = self.calculate_file_version_parents(key)
3232
 
            try:
3233
 
                knit_parents = parent_map[key]
3234
 
            except errors.RevisionNotPresent:
3235
 
                # Missing text!
3236
 
                knit_parents = None
3237
 
            if correct_parents != knit_parents:
3238
 
                wrong_parents[key] = (knit_parents, correct_parents)
3239
 
        return wrong_parents, unused_keys
3240
 
 
3241
 
 
3242
 
def _old_get_graph(repository, revision_id):
3243
 
    """DO NOT USE. That is all. I'm serious."""
3244
 
    graph = repository.get_graph()
3245
 
    revision_graph = dict(((key, value) for key, value in
3246
 
        graph.iter_ancestry([revision_id]) if value is not None))
3247
 
    return _strip_NULL_ghosts(revision_graph)
 
1820
        ui.ui_factory.note('repository converted')
 
1821
        pb.finished()
3248
1822
 
3249
1823
 
3250
1824
def _strip_NULL_ghosts(revision_graph):
3256
1830
        revision_graph[key] = tuple(parent for parent in parents if parent
3257
1831
            in revision_graph)
3258
1832
    return revision_graph
 
1833
 
 
1834
 
 
1835
def _iter_for_revno(repo, partial_history_cache, stop_index=None,
 
1836
                    stop_revision=None):
 
1837
    """Extend the partial history to include a given index
 
1838
 
 
1839
    If a stop_index is supplied, stop when that index has been reached.
 
1840
    If a stop_revision is supplied, stop when that revision is
 
1841
    encountered.  Otherwise, stop when the beginning of history is
 
1842
    reached.
 
1843
 
 
1844
    :param stop_index: The index which should be present.  When it is
 
1845
        present, history extension will stop.
 
1846
    :param stop_revision: The revision id which should be present.  When
 
1847
        it is encountered, history extension will stop.
 
1848
    """
 
1849
    start_revision = partial_history_cache[-1]
 
1850
    graph = repo.get_graph()
 
1851
    iterator = graph.iter_lefthand_ancestry(start_revision,
 
1852
        (_mod_revision.NULL_REVISION,))
 
1853
    try:
 
1854
        # skip the last revision in the list
 
1855
        iterator.next()
 
1856
        while True:
 
1857
            if (stop_index is not None and
 
1858
                len(partial_history_cache) > stop_index):
 
1859
                break
 
1860
            if partial_history_cache[-1] == stop_revision:
 
1861
                break
 
1862
            revision_id = iterator.next()
 
1863
            partial_history_cache.append(revision_id)
 
1864
    except StopIteration:
 
1865
        # No more history
 
1866
        return
 
1867
 
 
1868
 
 
1869
class _LazyListJoin(object):
 
1870
    """An iterable yielding the contents of many lists as one list.
 
1871
 
 
1872
    Each iterator made from this will reflect the current contents of the lists
 
1873
    at the time the iterator is made.
 
1874
    
 
1875
    This is used by Repository's _make_parents_provider implementation so that
 
1876
    it is safe to do::
 
1877
 
 
1878
      pp = repo._make_parents_provider()      # uses a list of fallback repos
 
1879
      pp.add_fallback_repository(other_repo)  # appends to that list
 
1880
      result = pp.get_parent_map(...)
 
1881
      # The result will include revs from other_repo
 
1882
    """
 
1883
 
 
1884
    def __init__(self, *list_parts):
 
1885
        self.list_parts = list_parts
 
1886
 
 
1887
    def __iter__(self):
 
1888
        full_list = []
 
1889
        for list_part in self.list_parts:
 
1890
            full_list.extend(list_part)
 
1891
        return iter(full_list)