← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: John Arbash Meinel
  • Date: 2008-10-04 14:10:13 UTC
  • mto: This revision was merged to the branch mainline in revision 3805.
  • Revision ID: john@arbash-meinel.com-20081004141013-yskxjlwtuy2k18ue
Playing around with expanding requests for btree index nodes into neighboring nodes.

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