← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

Fix up inter_changes with dirstate both C and python.

Show diffs side-by-side

added added

removed removed

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