~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-10-31 03:15:38 UTC
  • mfrom: (3806.1.1 contrib)
  • Revision ID: pqm@pqm.ubuntu.com-20081031031538-0ih0zi2owevf6fwu
Add contrib/bzr_ssh_path_limiter. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

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