← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

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