/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

First attempt to merge .dev and resolve the conflicts (but tests are 
failing)

Show diffs side-by-side

added added

removed removed

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