/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

  • Committer: Robert Collins
  • Date: 2008-08-20 02:07:36 UTC
  • mfrom: (3640 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3682.
  • Revision ID: robertc@robertcollins.net-20080820020736-g2xe4921zzxtymle
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
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
 
 
24
 
import bzrlib.bzrdir as bzrdir
 
23
 
 
24
from bzrlib import (
 
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,
 
36
    osutils,
 
37
    registry,
 
38
    remote,
 
39
    revision as _mod_revision,
 
40
    symbol_versioning,
 
41
    transactions,
 
42
    tsort,
 
43
    ui,
 
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
 
25
53
from bzrlib.decorators import needs_read_lock, needs_write_lock
26
 
import bzrlib.errors as errors
27
 
from bzrlib.errors import InvalidRevisionId
28
 
import bzrlib.gpg as gpg
29
 
from bzrlib.graph import Graph
30
54
from bzrlib.inter import InterObject
31
 
from bzrlib.inventory import Inventory
32
 
from bzrlib.knit import KnitVersionedFile, KnitPlainFactory
33
 
from bzrlib.lockable_files import LockableFiles, TransportLock
34
 
from bzrlib.lockdir import LockDir
35
 
from bzrlib.osutils import (safe_unicode, rand_bytes, compact_date, 
36
 
                            local_time_offset)
37
 
from bzrlib.revision import NULL_REVISION, Revision
38
 
from bzrlib.store.versioned import VersionedFileStore, WeaveStore
39
 
from bzrlib.store.text import TextStore
40
 
from bzrlib.symbol_versioning import *
41
 
from bzrlib.trace import mutter, note
42
 
from bzrlib.tree import RevisionTree
43
 
from bzrlib.tsort import topo_sort
44
 
from bzrlib.testament import Testament
45
 
from bzrlib.tree import EmptyTree
46
 
import bzrlib.ui
47
 
from bzrlib.weave import WeaveFile
48
 
import bzrlib.xml5
49
 
 
 
55
from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID
 
56
from bzrlib.symbol_versioning import (
 
57
        deprecated_method,
 
58
        one_one,
 
59
        one_two,
 
60
        one_three,
 
61
        one_six,
 
62
        )
 
63
from bzrlib.trace import mutter, mutter_callsite, note, warning
 
64
 
 
65
 
 
66
# Old formats display a warning, but only once
 
67
_deprecation_warning_done = False
 
68
 
 
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
50
450
 
51
451
class Repository(object):
52
452
    """Repository holding history for one or more branches.
55
455
    revisions and file history.  It's normally accessed only by the Branch,
56
456
    which views a particular line of development through that history.
57
457
 
58
 
    The Repository builds on top of Stores and a Transport, which respectively 
59
 
    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
60
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.
61
495
    """
62
496
 
63
 
    @needs_write_lock
64
 
    def add_inventory(self, revid, inv, parents):
65
 
        """Add the inventory inv to the repository as revid.
66
 
        
67
 
        :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
68
559
                        is known to have and are in the repository already.
69
560
 
70
 
        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.
71
563
        """
72
 
        assert inv.revision_id is None or inv.revision_id == revid, \
73
 
            "Mismatch between inventory revision" \
74
 
            " id and insertion revid (%r, %r)" % (inv.revision_id, revid)
75
 
        inv_text = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
76
 
        inv_sha1 = bzrlib.osutils.sha_string(inv_text)
77
 
        inv_vf = self.control_weaves.get_weave('inventory',
78
 
                                               self.get_transaction())
79
 
        self._inventory_add_lines(inv_vf, revid, parents, bzrlib.osutils.split_lines(inv_text))
80
 
        return inv_sha1
81
 
 
82
 
    def _inventory_add_lines(self, inv_vf, revid, parents, lines):
83
 
        final_parents = []
84
 
        for parent in parents:
85
 
            if parent in inv_vf:
86
 
                final_parents.append(parent)
87
 
 
88
 
        inv_vf.add_lines(revid, final_parents, lines)
89
 
 
90
 
    @needs_write_lock
91
 
    def add_revision(self, rev_id, rev, inv=None, config=None):
92
 
        """Add rev to the revision store as rev_id.
93
 
 
94
 
        :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.
95
589
        :param rev: The revision object.
96
590
        :param inv: The inventory for the revision. if None, it will be looked
97
591
                    up in the inventory storer
99
593
                       If supplied its signature_needed method will be used
100
594
                       to determine if a signature should be made.
101
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)
102
599
        if config is not None and config.signature_needed():
103
600
            if inv is None:
104
 
                inv = self.get_inventory(rev_id)
 
601
                inv = self.get_inventory(revision_id)
105
602
            plaintext = Testament(rev, inv).as_short_text()
106
603
            self.store_revision_signature(
107
 
                gpg.GPGStrategy(config), plaintext, rev_id)
108
 
        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,)]):
109
607
            if inv is None:
110
 
                raise errors.WeaveRevisionNotPresent(rev_id,
111
 
                                                     self.get_inventory_weave())
 
608
                raise errors.WeaveRevisionNotPresent(revision_id,
 
609
                                                     self.inventories)
112
610
            else:
113
611
                # yes, this is not suitable for adding with ghosts.
114
 
                self.add_inventory(rev_id, inv, rev.parent_ids)
115
 
        self._revision_store.add_revision(rev, self.get_transaction())
116
 
 
117
 
    @needs_read_lock
118
 
    def _all_possible_ids(self):
119
 
        """Return all the possible revisions that we could find."""
120
 
        return self.get_inventory_weave().versions()
121
 
 
122
 
    @needs_read_lock
 
612
                rev.inventory_sha1 = self.add_inventory(revision_id, inv,
 
613
                                                        rev.parent_ids)
 
614
        else:
 
615
            key = (revision_id,)
 
616
            rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
 
617
        self._add_revision(rev)
 
618
 
 
619
    def _add_revision(self, revision):
 
620
        text = self._serializer.write_revision_to_string(revision)
 
621
        key = (revision.revision_id,)
 
622
        parents = tuple((parent,) for parent in revision.parent_ids)
 
623
        self.revisions.add_lines(key, parents, osutils.split_lines(text))
 
624
 
123
625
    def all_revision_ids(self):
124
626
        """Returns a list of all the revision ids in the repository. 
125
627
 
 
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.
 
632
        """
 
633
        if 'evil' in debug.debug_flags:
 
634
            mutter_callsite(2, "all_revision_ids is linear with history.")
 
635
        return self._all_revision_ids()
 
636
 
 
637
    def _all_revision_ids(self):
 
638
        """Returns a list of all the revision ids in the repository. 
 
639
 
126
640
        These are in as much topological order as the underlying store can 
127
 
        present: for weaves ghosts may lead to a lack of correctness until
128
 
        the reweave updates the parents list.
 
641
        present.
129
642
        """
130
 
        if self._revision_store.text_store.listable():
131
 
            return self._revision_store.all_revision_ids(self.get_transaction())
132
 
        result = self._all_possible_ids()
133
 
        return self._eliminate_revisions_not_present(result)
 
643
        raise NotImplementedError(self._all_revision_ids)
134
644
 
135
645
    def break_lock(self):
136
646
        """Break a lock if one is present from another instance.
147
657
        Returns a set of the present revisions.
148
658
        """
149
659
        result = []
150
 
        for id in revision_ids:
151
 
            if self.has_revision(id):
152
 
               result.append(id)
153
 
        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()
154
664
 
155
665
    @staticmethod
156
666
    def create(a_bzrdir):
157
667
        """Construct the current default format repository in a_bzrdir."""
158
668
        return RepositoryFormat.get_default_format().initialize(a_bzrdir)
159
669
 
160
 
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
 
670
    def __init__(self, _format, a_bzrdir, control_files):
161
671
        """instantiate a Repository.
162
672
 
163
673
        :param _format: The format of the repository on disk.
172
682
        # the following are part of the public API for Repository:
173
683
        self.bzrdir = a_bzrdir
174
684
        self.control_files = control_files
175
 
        self._revision_store = _revision_store
176
 
        self.text_store = text_store
177
 
        # backwards compatability
178
 
        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
179
691
        # not right yet - should be more semantically clear ? 
180
692
        # 
181
 
        self.control_store = control_store
182
 
        self.control_weaves = control_store
183
693
        # TODO: make sure to construct the right store classes, etc, depending
184
694
        # on whether escaping is required.
 
695
        self._warn_if_deprecated()
 
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
185
711
 
186
712
    def __repr__(self):
187
 
        return '%s(%r)' % (self.__class__.__name__, 
188
 
                           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
189
733
 
190
734
    def is_locked(self):
191
735
        return self.control_files.is_locked()
192
736
 
193
 
    def lock_write(self):
194
 
        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
195
769
 
196
770
    def lock_read(self):
197
771
        self.control_files.lock_read()
 
772
        for repo in self._fallback_repositories:
 
773
            repo.lock_read()
 
774
        self._refresh_data()
198
775
 
199
776
    def get_physical_lock_status(self):
200
777
        return self.control_files.get_physical_lock_status()
201
778
 
202
 
    @needs_read_lock
203
 
    def missing_revision_ids(self, other, revision_id=None):
204
 
        """Return the revision ids that other has that this does not.
205
 
        
206
 
        These are returned in topological order.
207
 
 
208
 
        revision_id: only return revision ids included by revision_id.
209
 
        """
210
 
        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)
211
919
 
212
920
    @staticmethod
213
921
    def open(base):
216
924
        For instance, if the repository is at URL/.bzr/repository,
217
925
        Repository.open(URL) -> a Repository instance.
218
926
        """
219
 
        control = bzrlib.bzrdir.BzrDir.open(base)
 
927
        control = bzrdir.BzrDir.open(base)
220
928
        return control.open_repository()
221
929
 
222
 
    def copy_content_into(self, destination, revision_id=None, basis=None):
 
930
    def copy_content_into(self, destination, revision_id=None):
223
931
        """Make a complete copy of the content in self into destination.
224
932
        
225
933
        This is a destructive operation! Do not use it on existing 
226
934
        repositories.
227
935
        """
228
 
        return InterRepository.get(self, destination).copy_content(revision_id, basis)
229
 
 
230
 
    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):
231
961
        """Fetch the content required to construct revision_id from source.
232
962
 
233
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).
234
967
        """
235
 
        return InterRepository.get(source, self).fetch(revision_id=revision_id,
236
 
                                                       pb=pb)
237
 
 
238
 
    def get_commit_builder(self, branch, parents, config, timestamp=None, 
239
 
                           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,
240
988
                           revision_id=None):
241
989
        """Obtain a CommitBuilder for this repository.
242
990
        
249
997
        :param revprops: Optional dictionary of revision properties.
250
998
        :param revision_id: Optional revision id.
251
999
        """
252
 
        return CommitBuilder(self, parents, config, timestamp, timezone,
253
 
                             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
254
1004
 
255
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.')
256
1013
        self.control_files.unlock()
 
1014
        for repo in self._fallback_repositories:
 
1015
            repo.unlock()
257
1016
 
258
1017
    @needs_read_lock
259
 
    def clone(self, a_bzrdir, revision_id=None, basis=None):
 
1018
    def clone(self, a_bzrdir, revision_id=None):
260
1019
        """Clone this repository into a_bzrdir using the current format.
261
1020
 
262
1021
        Currently no check is made that the format of this repository and
263
1022
        the bzrdir format are compatible. FIXME RBC 20060201.
264
 
        """
 
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):
265
1072
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
266
1073
            # use target default format.
267
 
            result = a_bzrdir.create_repository()
268
 
        # FIXME RBC 20060209 split out the repository type to avoid this check ?
269
 
        elif isinstance(a_bzrdir._format,
270
 
                      (bzrlib.bzrdir.BzrDirFormat4,
271
 
                       bzrlib.bzrdir.BzrDirFormat5,
272
 
                       bzrlib.bzrdir.BzrDirFormat6)):
273
 
            result = a_bzrdir.open_repository()
 
1074
            dest_repo = a_bzrdir.create_repository()
274
1075
        else:
275
 
            result = self._format.initialize(a_bzrdir, shared=self.is_shared())
276
 
        self.copy_content_into(result, revision_id, basis)
277
 
        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
278
1083
 
279
1084
    @needs_read_lock
280
1085
    def has_revision(self, revision_id):
281
1086
        """True if this repository has a copy of the revision."""
282
 
        return self._revision_store.has_revision_id(revision_id,
283
 
                                                    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]
284
1108
 
285
1109
    @needs_read_lock
286
1110
    def get_revision_reconcile(self, revision_id):
291
1115
        be used by reconcile, or reconcile-alike commands that are correcting
292
1116
        or testing the revision graph.
293
1117
        """
294
 
        if not revision_id or not isinstance(revision_id, basestring):
295
 
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
296
 
        return self._revision_store.get_revision(revision_id,
297
 
                                                 self.get_transaction())
 
1118
        return self._get_revisions([revision_id])[0]
 
1119
 
 
1120
    @needs_read_lock
 
1121
    def get_revisions(self, revision_ids):
 
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]
298
1141
 
299
1142
    @needs_read_lock
300
1143
    def get_revision_xml(self, revision_id):
301
 
        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)
302
1148
        rev_tmp = StringIO()
303
1149
        # the current serializer..
304
 
        self._revision_store._serializer.write_revision(rev, rev_tmp)
 
1150
        self._serializer.write_revision(rev, rev_tmp)
305
1151
        rev_tmp.seek(0)
306
1152
        return rev_tmp.getvalue()
307
1153
 
 
1154
    def get_deltas_for_revisions(self, revisions):
 
1155
        """Produce a generator of revision deltas.
 
1156
        
 
1157
        Note that the input is a sequence of REVISIONS, not revision_ids.
 
1158
        Trees will be held in memory until the generator exits.
 
1159
        Each delta is relative to the revision's lefthand predecessor.
 
1160
        """
 
1161
        required_trees = set()
 
1162
        for revision in revisions:
 
1163
            required_trees.add(revision.revision_id)
 
1164
            required_trees.update(revision.parent_ids[:1])
 
1165
        trees = dict((t.get_revision_id(), t) for 
 
1166
                     t in self.revision_trees(required_trees))
 
1167
        for revision in revisions:
 
1168
            if not revision.parent_ids:
 
1169
                old_tree = self.revision_tree(None)
 
1170
            else:
 
1171
                old_tree = trees[revision.parent_ids[0]]
 
1172
            yield trees[revision.revision_id].changes_from(old_tree)
 
1173
 
308
1174
    @needs_read_lock
309
 
    def get_revision(self, revision_id):
310
 
        """Return the Revision object for a named revision"""
311
 
        r = self.get_revision_reconcile(revision_id)
312
 
        # weave corruption can lead to absent revision markers that should be
313
 
        # present.
314
 
        # the following test is reasonably cheap (it needs a single weave read)
315
 
        # and the weave is cached in read transactions. In write transactions
316
 
        # it is not cached but typically we only read a small number of
317
 
        # revisions. For knits when they are introduced we will probably want
318
 
        # to ensure that caching write transactions are in use.
319
 
        inv = self.get_inventory_weave()
320
 
        self._check_revision_parents(r, inv)
321
 
        return r
 
1175
    def get_revision_delta(self, revision_id):
 
1176
        """Return the delta for one revision.
322
1177
 
323
 
    def _check_revision_parents(self, revision, inventory):
324
 
        """Private to Repository and Fetch.
325
 
        
326
 
        This checks the parentage of revision in an inventory weave for 
327
 
        consistency and is only applicable to inventory-weave-for-ancestry
328
 
        using repository formats & fetchers.
 
1178
        The delta is relative to the left-hand predecessor of the
 
1179
        revision.
329
1180
        """
330
 
        weave_parents = inventory.get_parents(revision.revision_id)
331
 
        weave_names = inventory.versions()
332
 
        for parent_id in revision.parent_ids:
333
 
            if parent_id in weave_names:
334
 
                # this parent must not be a ghost.
335
 
                if not parent_id in weave_parents:
336
 
                    # but it is a ghost
337
 
                    raise errors.CorruptRepository(self)
 
1181
        r = self.get_revision(revision_id)
 
1182
        return list(self.get_deltas_for_revisions([r]))[0]
338
1183
 
339
1184
    @needs_write_lock
340
1185
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
341
1186
        signature = gpg_strategy.sign(plaintext)
342
 
        self._revision_store.add_revision_signature_text(revision_id,
343
 
                                                         signature,
344
 
                                                         self.get_transaction())
345
 
 
346
 
    def fileids_altered_by_revision_ids(self, revision_ids):
347
 
        """Find the file ids and versions affected by revisions.
348
 
 
349
 
        :param revisions: an iterable containing revision ids.
350
 
        :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
351
1198
        revision_ids. Each altered file-ids has the exact revision_ids that
352
1199
        altered it listed explicitly.
353
 
        """
354
 
        assert isinstance(self._format, (RepositoryFormat5,
355
 
                                         RepositoryFormat6,
356
 
                                         RepositoryFormat7,
357
 
                                         RepositoryFormatKnit1)), \
358
 
            "fileid_involved only supported for branches which store inventory as unnested xml"
359
 
        selected_revision_ids = set(revision_ids)
360
 
        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)
361
1232
        result = {}
362
1233
 
363
1234
        # this code needs to read every new line in every inventory for the
364
1235
        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
365
 
        # not pesent in one of those inventories is unnecessary but not 
 
1236
        # not present in one of those inventories is unnecessary but not 
366
1237
        # harmful because we are filtering by the revision id marker in the
367
1238
        # inventory lines : we only select file ids altered in one of those  
368
 
        # revisions. We dont need to see all lines in the inventory because
 
1239
        # revisions. We don't need to see all lines in the inventory because
369
1240
        # only those added in an inventory in rev X can contain a revision=X
370
1241
        # line.
371
 
        for line in w.iter_lines_added_or_present_in_versions(selected_revision_ids):
372
 
            start = line.find('file_id="')+9
373
 
            if start < 9: continue
374
 
            end = line.find('"', start)
375
 
            assert end>= 0
376
 
            file_id = _unescape_xml(line[start:end])
377
 
 
378
 
            start = line.find('revision="')+10
379
 
            if start < 10: continue
380
 
            end = line.find('"', start)
381
 
            assert end>= 0
382
 
            revision_id = _unescape_xml(line[start:end])
383
 
            if revision_id in selected_revision_ids:
384
 
                result.setdefault(file_id, set()).add(revision_id)
385
 
        return result
386
 
 
387
 
    @needs_read_lock
388
 
    def get_inventory_weave(self):
389
 
        return self.control_weaves.get_weave('inventory',
390
 
            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)
391
1522
 
392
1523
    @needs_read_lock
393
1524
    def get_inventory(self, revision_id):
394
 
        """Get Inventory object by hash."""
395
 
        return self.deserialise_inventory(
396
 
            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]
397
1558
 
398
1559
    def deserialise_inventory(self, revision_id, xml):
399
1560
        """Transform the xml into an inventory object. 
401
1562
        :param revision_id: The expected revision id of the inventory.
402
1563
        :param xml: A serialised inventory.
403
1564
        """
404
 
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
1565
        result = self._serializer.read_inventory_from_string(xml, revision_id)
 
1566
        if result.revision_id != revision_id:
 
1567
            raise AssertionError('revision id mismatch %s != %s' % (
 
1568
                result.revision_id, revision_id))
 
1569
        return result
 
1570
 
 
1571
    def serialise_inventory(self, inv):
 
1572
        return self._serializer.write_inventory_to_string(inv)
 
1573
 
 
1574
    def _serialise_inventory_to_lines(self, inv):
 
1575
        return self._serializer.write_inventory_to_lines(inv)
 
1576
 
 
1577
    def get_serializer_format(self):
 
1578
        return self._serializer.format_num
405
1579
 
406
1580
    @needs_read_lock
407
1581
    def get_inventory_xml(self, revision_id):
408
1582
        """Get inventory XML as a file object."""
 
1583
        texts = self._iter_inventory_xmls([revision_id])
409
1584
        try:
410
 
            assert isinstance(revision_id, basestring), type(revision_id)
411
 
            iw = self.get_inventory_weave()
412
 
            return iw.get_text(revision_id)
413
 
        except IndexError:
414
 
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
 
1585
            text, revision_id = texts.next()
 
1586
        except StopIteration:
 
1587
            raise errors.HistoryMissing(self, 'inventory', revision_id)
 
1588
        return text
415
1589
 
416
1590
    @needs_read_lock
417
1591
    def get_inventory_sha1(self, revision_id):
419
1593
        """
420
1594
        return self.get_revision(revision_id).inventory_sha1
421
1595
 
422
 
    @needs_read_lock
423
 
    def get_revision_graph(self, revision_id=None):
424
 
        """Return a dictionary containing the revision graph.
425
 
        
426
 
        :return: a dictionary of revision_id->revision_parents_list.
427
 
        """
428
 
        weave = self.get_inventory_weave()
429
 
        all_revisions = self._eliminate_revisions_not_present(weave.versions())
430
 
        entire_graph = dict([(node, weave.get_parents(node)) for 
431
 
                             node in all_revisions])
432
 
        if revision_id is None:
433
 
            return entire_graph
434
 
        elif revision_id not in entire_graph:
435
 
            raise errors.NoSuchRevision(self, revision_id)
436
 
        else:
437
 
            # add what can be reached from revision_id
438
 
            result = {}
439
 
            pending = set([revision_id])
440
 
            while len(pending) > 0:
441
 
                node = pending.pop()
442
 
                result[node] = entire_graph[node]
443
 
                for revision_id in result[node]:
444
 
                    if revision_id not in result:
445
 
                        pending.add(revision_id)
446
 
            return result
447
 
 
448
 
    @needs_read_lock
449
 
    def get_revision_graph_with_ghosts(self, revision_ids=None):
450
 
        """Return a graph of the revisions with ghosts marked as applicable.
451
 
 
452
 
        :param revision_ids: an iterable of revisions to graph or None for all.
453
 
        :return: a Graph object with the graph reachable from revision_ids.
454
 
        """
455
 
        result = Graph()
456
 
        if not revision_ids:
457
 
            pending = set(self.all_revision_ids())
458
 
            required = set([])
459
 
        else:
460
 
            pending = set(revision_ids)
461
 
            required = set(revision_ids)
462
 
        done = set([])
463
 
        while len(pending):
464
 
            revision_id = pending.pop()
465
 
            try:
466
 
                rev = self.get_revision(revision_id)
467
 
            except errors.NoSuchRevision:
468
 
                if revision_id in required:
469
 
                    raise
470
 
                # a ghost
471
 
                result.add_ghost(revision_id)
472
 
                continue
473
 
            for parent_id in rev.parent_ids:
474
 
                # is this queued or done ?
475
 
                if (parent_id not in pending and
476
 
                    parent_id not in done):
477
 
                    # no, queue it.
478
 
                    pending.add(parent_id)
479
 
            result.add_node(revision_id, rev.parent_ids)
480
 
            done.add(revision_id)
481
 
        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]
482
1618
 
483
1619
    @needs_read_lock
484
1620
    def get_revision_inventory(self, revision_id):
496
1632
        else:
497
1633
            return self.get_inventory(revision_id)
498
1634
 
499
 
    @needs_read_lock
500
1635
    def is_shared(self):
501
1636
        """Return True if this repository is flagged as a shared repository."""
502
1637
        raise NotImplementedError(self.is_shared)
508
1643
        reconciler = RepoReconciler(self, thorough=thorough)
509
1644
        reconciler.reconcile()
510
1645
        return reconciler
511
 
    
 
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
 
512
1657
    @needs_read_lock
513
1658
    def revision_tree(self, revision_id):
514
1659
        """Return Tree for a revision on this branch.
515
1660
 
516
 
        `revision_id` may be None for the null revision, in which case
517
 
        an `EmptyTree` is returned."""
 
1661
        `revision_id` may be None for the empty tree revision.
 
1662
        """
518
1663
        # TODO: refactor this to use an existing revision object
519
1664
        # so we don't need to read it in twice.
520
 
        if revision_id is None or revision_id == NULL_REVISION:
521
 
            return EmptyTree()
 
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)
522
1668
        else:
523
1669
            inv = self.get_revision_inventory(revision_id)
524
1670
            return RevisionTree(self, inv, revision_id)
525
1671
 
 
1672
    def revision_trees(self, revision_ids):
 
1673
        """Return Tree for a revision on this branch.
 
1674
 
 
1675
        `revision_id` may not be None or 'null:'"""
 
1676
        inventories = self.iter_inventories(revision_ids)
 
1677
        for inv in inventories:
 
1678
            yield RevisionTree(self, inv, inv.revision_id)
 
1679
 
526
1680
    @needs_read_lock
527
 
    def get_ancestry(self, revision_id):
 
1681
    def get_ancestry(self, revision_id, topo_sorted=True):
528
1682
        """Return a list of revision-ids integrated by a revision.
 
1683
 
 
1684
        The first element of the list is always None, indicating the origin 
 
1685
        revision.  This might change when we have history horizons, or 
 
1686
        perhaps we should have a new API.
529
1687
        
530
1688
        This is topologically sorted.
531
1689
        """
532
 
        if revision_id is None:
 
1690
        if _mod_revision.is_null(revision_id):
533
1691
            return [None]
534
1692
        if not self.has_revision(revision_id):
535
1693
            raise errors.NoSuchRevision(self, revision_id)
536
 
        w = self.get_inventory_weave()
537
 
        candidates = w.get_ancestry(revision_id)
538
 
        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
        """
539
1720
 
540
1721
    @needs_read_lock
 
1722
    @deprecated_method(one_six)
541
1723
    def print_file(self, file, revision_id):
542
1724
        """Print `file` to stdout.
543
1725
        
558
1740
    def get_transaction(self):
559
1741
        return self.control_files.get_transaction()
560
1742
 
561
 
    def revision_parents(self, revid):
562
 
        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
563
1799
 
564
1800
    @needs_write_lock
565
1801
    def set_make_working_trees(self, new_value):
585
1821
    @needs_read_lock
586
1822
    def has_signature_for_revision_id(self, revision_id):
587
1823
        """Query for a revision signature for revision_id in the repository."""
588
 
        return self._revision_store.has_signature(revision_id,
589
 
                                                  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
590
1829
 
591
1830
    @needs_read_lock
592
1831
    def get_signature_text(self, revision_id):
593
1832
        """Return the text for a signature."""
594
 
        return self._revision_store.get_signature_text(revision_id,
595
 
                                                       self.get_transaction())
596
 
 
597
 
 
598
 
class AllInOneRepository(Repository):
599
 
    """Legacy support - the repository behaviour for all-in-one branches."""
600
 
 
601
 
    def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
602
 
        # we reuse one control files instance.
603
 
        dir_mode = a_bzrdir._control_files._dir_mode
604
 
        file_mode = a_bzrdir._control_files._file_mode
605
 
 
606
 
        def get_store(name, compressed=True, prefixed=False):
607
 
            # FIXME: This approach of assuming stores are all entirely compressed
608
 
            # or entirely uncompressed is tidy, but breaks upgrade from 
609
 
            # some existing branches where there's a mixture; we probably 
610
 
            # still want the option to look for both.
611
 
            relpath = a_bzrdir._control_files._escape(name)
612
 
            store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
613
 
                              prefixed=prefixed, compressed=compressed,
614
 
                              dir_mode=dir_mode,
615
 
                              file_mode=file_mode)
616
 
            #if self._transport.should_cache():
617
 
            #    cache_path = os.path.join(self.cache_root, name)
618
 
            #    os.mkdir(cache_path)
619
 
            #    store = bzrlib.store.CachedStore(store, cache_path)
620
 
            return store
621
 
 
622
 
        # not broken out yet because the controlweaves|inventory_store
623
 
        # and text_store | weave_store bits are still different.
624
 
        if isinstance(_format, RepositoryFormat4):
625
 
            # cannot remove these - there is still no consistent api 
626
 
            # which allows access to this old info.
627
 
            self.inventory_store = get_store('inventory-store')
628
 
            text_store = get_store('text-store')
629
 
        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
 
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')
630
1839
 
631
1840
    @needs_read_lock
632
 
    def is_shared(self):
633
 
        """AllInOne repositories cannot be shared."""
634
 
        return False
635
 
 
636
 
    @needs_write_lock
637
 
    def set_make_working_trees(self, new_value):
638
 
        """Set the policy flag for making working trees when creating branches.
639
 
 
640
 
        This only applies to branches that use this repository.
641
 
 
642
 
        The default is 'True'.
643
 
        :param new_value: True to restore the default, False to disable making
644
 
                          working trees.
 
1841
    def check(self, revision_ids=None):
 
1842
        """Check consistency of all history of given revision_ids.
 
1843
 
 
1844
        Different repository implementations should override _check().
 
1845
 
 
1846
        :param revision_ids: A non-empty list of revision_ids whose ancestry
 
1847
             will be checked.  Typically the last revision_id of a branch.
645
1848
        """
646
 
        raise NotImplementedError(self.set_make_working_trees)
 
1849
        return self._check(revision_ids)
 
1850
 
 
1851
    def _check(self, revision_ids):
 
1852
        result = check.Check(self)
 
1853
        result.check()
 
1854
        return result
 
1855
 
 
1856
    def _warn_if_deprecated(self):
 
1857
        global _deprecation_warning_done
 
1858
        if _deprecation_warning_done:
 
1859
            return
 
1860
        _deprecation_warning_done = True
 
1861
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
1862
                % (self._format, self.bzrdir.transport.base))
 
1863
 
 
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)
647
1882
    
648
 
    def make_working_trees(self):
649
 
        """Returns the policy for making working trees on new branches."""
650
 
        return True
 
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.
 
1891
        """
 
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')
651
1927
 
652
1928
 
653
1929
def install_revision(repository, rev, revision_tree):
654
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."""
655
1955
    present_parents = []
656
1956
    parent_trees = {}
657
1957
    for p_id in rev.parent_ids:
659
1959
            present_parents.append(p_id)
660
1960
            parent_trees[p_id] = repository.revision_tree(p_id)
661
1961
        else:
662
 
            parent_trees[p_id] = EmptyTree()
 
1962
            parent_trees[p_id] = repository.revision_tree(None)
663
1963
 
664
1964
    inv = revision_tree.inventory
665
 
    
 
1965
    entries = inv.iter_entries()
 
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)
666
1976
    # Add the texts that are not already present
667
 
    for path, ie in inv.iter_entries():
668
 
        w = repository.weave_store.get_weave_or_empty(ie.file_id,
669
 
                repository.get_transaction())
670
 
        if ie.revision not in w:
671
 
            text_parents = []
672
 
            # FIXME: TODO: The following loop *may* be overlapping/duplicate
673
 
            # with inventoryEntry.find_previous_heads(). if it is, then there
674
 
            # is a latent bug here where the parents may have ancestors of each
675
 
            # other. RBC, AB
676
 
            for revision, tree in parent_trees.iteritems():
677
 
                if ie.file_id not in tree:
678
 
                    continue
679
 
                parent_id = tree.inventory[ie.file_id].revision
680
 
                if parent_id in text_parents:
681
 
                    continue
682
 
                text_parents.append(parent_id)
683
 
                    
684
 
            vfile = repository.weave_store.get_weave_or_empty(ie.file_id, 
685
 
                repository.get_transaction())
686
 
            lines = revision_tree.get_file(ie.file_id).readlines()
687
 
            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)
688
1993
    try:
689
1994
        # install the inventory
690
1995
        repository.add_inventory(rev.revision_id, inv, present_parents)
691
1996
    except errors.RevisionAlreadyPresent:
692
1997
        pass
 
1998
    if signature is not None:
 
1999
        repository.add_signature_text(rev.revision_id, signature)
693
2000
    repository.add_revision(rev.revision_id, rev, inv)
694
2001
 
695
2002
 
696
2003
class MetaDirRepository(Repository):
697
 
    """Repositories in the new meta-dir layout."""
698
 
 
699
 
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
700
 
        super(MetaDirRepository, self).__init__(_format,
701
 
                                                a_bzrdir,
702
 
                                                control_files,
703
 
                                                _revision_store,
704
 
                                                control_store,
705
 
                                                text_store)
706
 
 
707
 
        dir_mode = self.control_files._dir_mode
708
 
        file_mode = self.control_files._file_mode
709
 
 
710
 
    @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
 
711
2014
    def is_shared(self):
712
2015
        """Return True if this repository is flagged as a shared repository."""
713
 
        return self.control_files._transport.has('shared-storage')
 
2016
        return self._transport.has('shared-storage')
714
2017
 
715
2018
    @needs_write_lock
716
2019
    def set_make_working_trees(self, new_value):
724
2027
        """
725
2028
        if new_value:
726
2029
            try:
727
 
                self.control_files._transport.delete('no-working-trees')
 
2030
                self._transport.delete('no-working-trees')
728
2031
            except errors.NoSuchFile:
729
2032
                pass
730
2033
        else:
731
 
            self.control_files.put_utf8('no-working-trees', '')
 
2034
            self._transport.put_bytes('no-working-trees', '',
 
2035
                mode=self.bzrdir._get_file_mode())
732
2036
    
733
2037
    def make_working_trees(self):
734
2038
        """Returns the policy for making working trees on new branches."""
735
 
        return not self.control_files._transport.has('no-working-trees')
736
 
 
737
 
 
738
 
class KnitRepository(MetaDirRepository):
739
 
    """Knit format repository."""
740
 
 
741
 
    def _inventory_add_lines(self, inv_vf, revid, parents, lines):
742
 
        inv_vf.add_lines_with_ghosts(revid, parents, lines)
743
 
 
744
 
    @needs_read_lock
745
 
    def all_revision_ids(self):
746
 
        """See Repository.all_revision_ids()."""
747
 
        return self._revision_store.all_revision_ids(self.get_transaction())
748
 
 
749
 
    def fileid_involved_between_revs(self, from_revid, to_revid):
750
 
        """Find file_id(s) which are involved in the changes between revisions.
751
 
 
752
 
        This determines the set of revisions which are involved, and then
753
 
        finds all file ids affected by those revisions.
754
 
        """
755
 
        vf = self._get_revision_vf()
756
 
        from_set = set(vf.get_ancestry(from_revid))
757
 
        to_set = set(vf.get_ancestry(to_revid))
758
 
        changed = to_set.difference(from_set)
759
 
        return self._fileid_involved_by_set(changed)
760
 
 
761
 
    def fileid_involved(self, last_revid=None):
762
 
        """Find all file_ids modified in the ancestry of last_revid.
763
 
 
764
 
        :param last_revid: If None, last_revision() will be used.
765
 
        """
766
 
        if not last_revid:
767
 
            changed = set(self.all_revision_ids())
768
 
        else:
769
 
            changed = set(self.get_ancestry(last_revid))
770
 
        if None in changed:
771
 
            changed.remove(None)
772
 
        return self._fileid_involved_by_set(changed)
773
 
 
774
 
    @needs_read_lock
775
 
    def get_ancestry(self, revision_id):
776
 
        """Return a list of revision-ids integrated by a revision.
777
 
        
778
 
        This is topologically sorted.
779
 
        """
780
 
        if revision_id is None:
781
 
            return [None]
782
 
        vf = self._get_revision_vf()
783
 
        try:
784
 
            return [None] + vf.get_ancestry(revision_id)
785
 
        except errors.RevisionNotPresent:
786
 
            raise errors.NoSuchRevision(self, revision_id)
787
 
 
788
 
    @needs_read_lock
789
 
    def get_revision(self, revision_id):
790
 
        """Return the Revision object for a named revision"""
791
 
        return self.get_revision_reconcile(revision_id)
792
 
 
793
 
    @needs_read_lock
794
 
    def get_revision_graph(self, revision_id=None):
795
 
        """Return a dictionary containing the revision graph.
796
 
        
797
 
        :return: a dictionary of revision_id->revision_parents_list.
798
 
        """
799
 
        weave = self._get_revision_vf()
800
 
        entire_graph = weave.get_graph()
801
 
        if revision_id is None:
802
 
            return weave.get_graph()
803
 
        elif revision_id not in weave:
804
 
            raise errors.NoSuchRevision(self, revision_id)
805
 
        else:
806
 
            # add what can be reached from revision_id
807
 
            result = {}
808
 
            pending = set([revision_id])
809
 
            while len(pending) > 0:
810
 
                node = pending.pop()
811
 
                result[node] = weave.get_parents(node)
812
 
                for revision_id in result[node]:
813
 
                    if revision_id not in result:
814
 
                        pending.add(revision_id)
815
 
            return result
816
 
 
817
 
    @needs_read_lock
818
 
    def get_revision_graph_with_ghosts(self, revision_ids=None):
819
 
        """Return a graph of the revisions with ghosts marked as applicable.
820
 
 
821
 
        :param revision_ids: an iterable of revisions to graph or None for all.
822
 
        :return: a Graph object with the graph reachable from revision_ids.
823
 
        """
824
 
        result = Graph()
825
 
        vf = self._get_revision_vf()
826
 
        versions = set(vf.versions())
827
 
        if not revision_ids:
828
 
            pending = set(self.all_revision_ids())
829
 
            required = set([])
830
 
        else:
831
 
            pending = set(revision_ids)
832
 
            required = set(revision_ids)
833
 
        done = set([])
834
 
        while len(pending):
835
 
            revision_id = pending.pop()
836
 
            if not revision_id in versions:
837
 
                if revision_id in required:
838
 
                    raise errors.NoSuchRevision(self, revision_id)
839
 
                # a ghost
840
 
                result.add_ghost(revision_id)
841
 
                # mark it as done so we dont try for it again.
842
 
                done.add(revision_id)
843
 
                continue
844
 
            parent_ids = vf.get_parents_with_ghosts(revision_id)
845
 
            for parent_id in parent_ids:
846
 
                # is this queued or done ?
847
 
                if (parent_id not in pending and
848
 
                    parent_id not in done):
849
 
                    # no, queue it.
850
 
                    pending.add(parent_id)
851
 
            result.add_node(revision_id, parent_ids)
852
 
            done.add(revision_id)
853
 
        return result
854
 
 
855
 
    def _get_revision_vf(self):
856
 
        """:return: a versioned file containing the revisions."""
857
 
        vf = self._revision_store.get_revision_file(self.get_transaction())
858
 
        return vf
859
 
 
860
 
    @needs_write_lock
861
 
    def reconcile(self, other=None, thorough=False):
862
 
        """Reconcile this repository."""
863
 
        from bzrlib.reconcile import KnitReconciler
864
 
        reconciler = KnitReconciler(self, thorough=thorough)
865
 
        reconciler.reconcile()
866
 
        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
867
2058
    
868
 
    def revision_parents(self, revid):
869
 
        return self._get_revision_vf().get_parents(rev_id)
 
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
870
2070
 
871
2071
class RepositoryFormat(object):
872
2072
    """A repository format.
877
2077
       children.
878
2078
     * an open routine which returns a Repository instance.
879
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
 
880
2085
    Formats are placed in an dict by their format string for reference 
881
2086
    during opening. These should be subclasses of RepositoryFormat
882
2087
    for consistency.
889
2094
    _matchingbzrdir - the bzrdir format that the repository format was
890
2095
    originally written to work with. This can be used if manually
891
2096
    constructing a bzrdir and repository, or more commonly for test suite
892
 
    parameterisation.
 
2097
    parameterization.
893
2098
    """
894
2099
 
895
 
    _default_format = None
896
 
    """The default format used for new repositories."""
897
 
 
898
 
    _formats = {}
899
 
    """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
 
2106
 
 
2107
    def __str__(self):
 
2108
        return "<%s>" % self.__class__.__name__
 
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
900
2116
 
901
2117
    @classmethod
902
2118
    def find_format(klass, a_bzrdir):
903
 
        """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
        """
904
2125
        try:
905
2126
            transport = a_bzrdir.get_repository_transport(None)
906
2127
            format_string = transport.get("format").read()
907
 
            return klass._formats[format_string]
 
2128
            return format_registry.get(format_string)
908
2129
        except errors.NoSuchFile:
909
2130
            raise errors.NoRepositoryPresent(a_bzrdir)
910
2131
        except KeyError:
911
 
            raise errors.UnknownFormatError(format_string)
912
 
 
913
 
    def _get_control_store(self, repo_transport, control_files):
914
 
        """Return the control store for this repository."""
915
 
        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())
916
2142
    
917
2143
    @classmethod
918
2144
    def get_default_format(klass):
919
2145
        """Return the current default format."""
920
 
        return klass._default_format
 
2146
        from bzrlib import bzrdir
 
2147
        return bzrdir.format_registry.make_bzrdir('default').repository_format
921
2148
 
922
2149
    def get_format_string(self):
923
2150
        """Return the ASCII format string that identifies this format.
928
2155
        raise NotImplementedError(self.get_format_string)
929
2156
 
930
2157
    def get_format_description(self):
931
 
        """Return the short desciption for this format."""
 
2158
        """Return the short description for this format."""
932
2159
        raise NotImplementedError(self.get_format_description)
933
2160
 
934
 
    def _get_revision_store(self, repo_transport, control_files):
935
 
        """Return the revision store object for this a_bzrdir."""
936
 
        raise NotImplementedError(self._get_revision_store)
937
 
 
938
 
    def _get_text_rev_store(self,
939
 
                            transport,
940
 
                            control_files,
941
 
                            name,
942
 
                            compressed=True,
943
 
                            prefixed=False,
944
 
                            serializer=None):
945
 
        """Common logic for getting a revision store for a repository.
946
 
        
947
 
        see self._get_revision_store for the subclass-overridable method to 
948
 
        get the store for a repository.
949
 
        """
950
 
        from bzrlib.store.revision.text import TextRevisionStore
951
 
        dir_mode = control_files._dir_mode
952
 
        file_mode = control_files._file_mode
953
 
        text_store =TextStore(transport.clone(name),
954
 
                              prefixed=prefixed,
955
 
                              compressed=compressed,
956
 
                              dir_mode=dir_mode,
957
 
                              file_mode=file_mode)
958
 
        _revision_store = TextRevisionStore(text_store, serializer)
959
 
        return _revision_store
960
 
 
 
2161
    # TODO: this shouldn't be in the base class, it's specific to things that
 
2162
    # use weaves or knits -- mbp 20070207
961
2163
    def _get_versioned_file_store(self,
962
2164
                                  name,
963
2165
                                  transport,
964
2166
                                  control_files,
965
2167
                                  prefixed=True,
966
 
                                  versionedfile_class=WeaveFile,
 
2168
                                  versionedfile_class=None,
 
2169
                                  versionedfile_kwargs={},
967
2170
                                  escaped=False):
 
2171
        if versionedfile_class is None:
 
2172
            versionedfile_class = self._versionedfile_class
968
2173
        weave_transport = control_files._transport.clone(name)
969
2174
        dir_mode = control_files._dir_mode
970
2175
        file_mode = control_files._file_mode
972
2177
                                  dir_mode=dir_mode,
973
2178
                                  file_mode=file_mode,
974
2179
                                  versionedfile_class=versionedfile_class,
 
2180
                                  versionedfile_kwargs=versionedfile_kwargs,
975
2181
                                  escaped=escaped)
976
2182
 
977
2183
    def initialize(self, a_bzrdir, shared=False):
979
2185
 
980
2186
        :param a_bzrdir: The bzrdir to put the new repository in it.
981
2187
        :param shared: The repository should be initialized as a sharable one.
982
 
 
 
2188
        :returns: The new repository object.
 
2189
        
983
2190
        This may raise UninitializableFormat if shared repository are not
984
2191
        compatible the a_bzrdir.
985
2192
        """
 
2193
        raise NotImplementedError(self.initialize)
986
2194
 
987
2195
    def is_supported(self):
988
2196
        """Is this format supported?
993
2201
        """
994
2202
        return True
995
2203
 
 
2204
    def check_conversion_target(self, target_format):
 
2205
        raise NotImplementedError(self.check_conversion_target)
 
2206
 
996
2207
    def open(self, a_bzrdir, _found=False):
997
2208
        """Return an instance of this format for the bzrdir a_bzrdir.
998
2209
        
1000
2211
        """
1001
2212
        raise NotImplementedError(self.open)
1002
2213
 
1003
 
    @classmethod
1004
 
    def register_format(klass, format):
1005
 
        klass._formats[format.get_format_string()] = format
1006
 
 
1007
 
    @classmethod
1008
 
    def set_default_format(klass, format):
1009
 
        klass._default_format = format
1010
 
 
1011
 
    @classmethod
1012
 
    def unregister_format(klass, format):
1013
 
        assert klass._formats[format.get_format_string()] is format
1014
 
        del klass._formats[format.get_format_string()]
1015
 
 
1016
 
 
1017
 
class PreSplitOutRepositoryFormat(RepositoryFormat):
1018
 
    """Base class for the pre split out repository formats."""
1019
 
 
1020
 
    def initialize(self, a_bzrdir, shared=False, _internal=False):
1021
 
        """Create a weave repository.
1022
 
        
1023
 
        TODO: when creating split out bzr branch formats, move this to a common
1024
 
        base for Format5, Format6. or something like that.
1025
 
        """
1026
 
        from bzrlib.weavefile import write_weave_v5
1027
 
        from bzrlib.weave import Weave
1028
 
 
1029
 
        if shared:
1030
 
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
1031
 
 
1032
 
        if not _internal:
1033
 
            # always initialized when the bzrdir is.
1034
 
            return self.open(a_bzrdir, _found=True)
1035
 
        
1036
 
        # Create an empty weave
1037
 
        sio = StringIO()
1038
 
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
1039
 
        empty_weave = sio.getvalue()
1040
 
 
1041
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
1042
 
        dirs = ['revision-store', 'weaves']
1043
 
        files = [('inventory.weave', StringIO(empty_weave)),
1044
 
                 ]
1045
 
        
1046
 
        # FIXME: RBC 20060125 dont peek under the covers
1047
 
        # NB: no need to escape relative paths that are url safe.
1048
 
        control_files = LockableFiles(a_bzrdir.transport, 'branch-lock',
1049
 
                                      TransportLock)
1050
 
        control_files.create_lock()
1051
 
        control_files.lock_write()
1052
 
        control_files._transport.mkdir_multi(dirs,
1053
 
                mode=control_files._dir_mode)
1054
 
        try:
1055
 
            for file, content in files:
1056
 
                control_files.put(file, content)
1057
 
        finally:
1058
 
            control_files.unlock()
1059
 
        return self.open(a_bzrdir, _found=True)
1060
 
 
1061
 
    def _get_control_store(self, repo_transport, control_files):
1062
 
        """Return the control store for this repository."""
1063
 
        return self._get_versioned_file_store('',
1064
 
                                              repo_transport,
1065
 
                                              control_files,
1066
 
                                              prefixed=False)
1067
 
 
1068
 
    def _get_text_store(self, transport, control_files):
1069
 
        """Get a store for file texts for this format."""
1070
 
        raise NotImplementedError(self._get_text_store)
1071
 
 
1072
 
    def open(self, a_bzrdir, _found=False):
1073
 
        """See RepositoryFormat.open()."""
1074
 
        if not _found:
1075
 
            # we are being called directly and must probe.
1076
 
            raise NotImplementedError
1077
 
 
1078
 
        repo_transport = a_bzrdir.get_repository_transport(None)
1079
 
        control_files = a_bzrdir._control_files
1080
 
        text_store = self._get_text_store(repo_transport, control_files)
1081
 
        control_store = self._get_control_store(repo_transport, control_files)
1082
 
        _revision_store = self._get_revision_store(repo_transport, control_files)
1083
 
        return AllInOneRepository(_format=self,
1084
 
                                  a_bzrdir=a_bzrdir,
1085
 
                                  _revision_store=_revision_store,
1086
 
                                  control_store=control_store,
1087
 
                                  text_store=text_store)
1088
 
 
1089
 
 
1090
 
class RepositoryFormat4(PreSplitOutRepositoryFormat):
1091
 
    """Bzr repository format 4.
1092
 
 
1093
 
    This repository format has:
1094
 
     - flat stores
1095
 
     - TextStores for texts, inventories,revisions.
1096
 
 
1097
 
    This format is deprecated: it indexes texts using a text id which is
1098
 
    removed in format 5; initializationa and write support for this format
1099
 
    has been removed.
1100
 
    """
1101
 
 
1102
 
    def __init__(self):
1103
 
        super(RepositoryFormat4, self).__init__()
1104
 
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat4()
1105
 
 
1106
 
    def get_format_description(self):
1107
 
        """See RepositoryFormat.get_format_description()."""
1108
 
        return "Repository format 4"
1109
 
 
1110
 
    def initialize(self, url, shared=False, _internal=False):
1111
 
        """Format 4 branches cannot be created."""
1112
 
        raise errors.UninitializableFormat(self)
1113
 
 
1114
 
    def is_supported(self):
1115
 
        """Format 4 is not supported.
1116
 
 
1117
 
        It is not supported because the model changed from 4 to 5 and the
1118
 
        conversion logic is expensive - so doing it on the fly was not 
1119
 
        feasible.
1120
 
        """
1121
 
        return False
1122
 
 
1123
 
    def _get_control_store(self, repo_transport, control_files):
1124
 
        """Format 4 repositories have no formal control store at this point.
1125
 
        
1126
 
        This will cause any control-file-needing apis to fail - this is desired.
1127
 
        """
1128
 
        return None
1129
 
    
1130
 
    def _get_revision_store(self, repo_transport, control_files):
1131
 
        """See RepositoryFormat._get_revision_store()."""
1132
 
        from bzrlib.xml4 import serializer_v4
1133
 
        return self._get_text_rev_store(repo_transport,
1134
 
                                        control_files,
1135
 
                                        'revision-store',
1136
 
                                        serializer=serializer_v4)
1137
 
 
1138
 
    def _get_text_store(self, transport, control_files):
1139
 
        """See RepositoryFormat._get_text_store()."""
1140
 
 
1141
 
 
1142
 
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1143
 
    """Bzr control format 5.
1144
 
 
1145
 
    This repository format has:
1146
 
     - weaves for file texts and inventory
1147
 
     - flat stores
1148
 
     - TextStores for revisions and signatures.
1149
 
    """
1150
 
 
1151
 
    def __init__(self):
1152
 
        super(RepositoryFormat5, self).__init__()
1153
 
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat5()
1154
 
 
1155
 
    def get_format_description(self):
1156
 
        """See RepositoryFormat.get_format_description()."""
1157
 
        return "Weave repository format 5"
1158
 
 
1159
 
    def _get_revision_store(self, repo_transport, control_files):
1160
 
        """See RepositoryFormat._get_revision_store()."""
1161
 
        """Return the revision store object for this a_bzrdir."""
1162
 
        return self._get_text_rev_store(repo_transport,
1163
 
                                        control_files,
1164
 
                                        'revision-store',
1165
 
                                        compressed=False)
1166
 
 
1167
 
    def _get_text_store(self, transport, control_files):
1168
 
        """See RepositoryFormat._get_text_store()."""
1169
 
        return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
1170
 
 
1171
 
 
1172
 
class RepositoryFormat6(PreSplitOutRepositoryFormat):
1173
 
    """Bzr control format 6.
1174
 
 
1175
 
    This repository format has:
1176
 
     - weaves for file texts and inventory
1177
 
     - hash subdirectory based stores.
1178
 
     - TextStores for revisions and signatures.
1179
 
    """
1180
 
 
1181
 
    def __init__(self):
1182
 
        super(RepositoryFormat6, self).__init__()
1183
 
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat6()
1184
 
 
1185
 
    def get_format_description(self):
1186
 
        """See RepositoryFormat.get_format_description()."""
1187
 
        return "Weave repository format 6"
1188
 
 
1189
 
    def _get_revision_store(self, repo_transport, control_files):
1190
 
        """See RepositoryFormat._get_revision_store()."""
1191
 
        return self._get_text_rev_store(repo_transport,
1192
 
                                        control_files,
1193
 
                                        'revision-store',
1194
 
                                        compressed=False,
1195
 
                                        prefixed=True)
1196
 
 
1197
 
    def _get_text_store(self, transport, control_files):
1198
 
        """See RepositoryFormat._get_text_store()."""
1199
 
        return self._get_versioned_file_store('weaves', transport, control_files)
1200
 
 
1201
2214
 
1202
2215
class MetaDirRepositoryFormat(RepositoryFormat):
1203
 
    """Common base class for the new repositories using the metadir layour."""
 
2216
    """Common base class for the new repositories using the metadir layout."""
 
2217
 
 
2218
    rich_root_data = False
 
2219
    supports_tree_reference = False
 
2220
    supports_external_lookups = False
 
2221
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1204
2222
 
1205
2223
    def __init__(self):
1206
2224
        super(MetaDirRepositoryFormat, self).__init__()
1207
 
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirMetaFormat1()
1208
2225
 
1209
2226
    def _create_control_files(self, a_bzrdir):
1210
2227
        """Create the required files and the initial control_files object."""
1211
 
        # FIXME: RBC 20060125 dont peek under the covers
 
2228
        # FIXME: RBC 20060125 don't peek under the covers
1212
2229
        # NB: no need to escape relative paths that are url safe.
1213
2230
        repository_transport = a_bzrdir.get_repository_transport(self)
1214
 
        control_files = LockableFiles(repository_transport, 'lock', LockDir)
 
2231
        control_files = lockable_files.LockableFiles(repository_transport,
 
2232
                                'lock', lockdir.LockDir)
1215
2233
        control_files.create_lock()
1216
2234
        return control_files
1217
2235
 
1219
2237
        """Upload the initial blank content."""
1220
2238
        control_files = self._create_control_files(a_bzrdir)
1221
2239
        control_files.lock_write()
 
2240
        transport = control_files._transport
 
2241
        if shared == True:
 
2242
            utf8_files += [('shared-storage', '')]
1222
2243
        try:
1223
 
            control_files._transport.mkdir_multi(dirs,
1224
 
                    mode=control_files._dir_mode)
1225
 
            for file, content in files:
1226
 
                control_files.put(file, content)
1227
 
            for file, content in utf8_files:
1228
 
                control_files.put_utf8(file, content)
1229
 
            if shared == True:
1230
 
                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())
1231
2251
        finally:
1232
2252
            control_files.unlock()
1233
2253
 
1234
2254
 
1235
 
class RepositoryFormat7(MetaDirRepositoryFormat):
1236
 
    """Bzr repository 7.
1237
 
 
1238
 
    This repository format has:
1239
 
     - weaves for file texts and inventory
1240
 
     - hash subdirectory based stores.
1241
 
     - TextStores for revisions and signatures.
1242
 
     - a format marker of its own
1243
 
     - an optional 'shared-storage' flag
1244
 
     - an optional 'no-working-trees' flag
1245
 
    """
1246
 
 
1247
 
    def _get_control_store(self, repo_transport, control_files):
1248
 
        """Return the control store for this repository."""
1249
 
        return self._get_versioned_file_store('',
1250
 
                                              repo_transport,
1251
 
                                              control_files,
1252
 
                                              prefixed=False)
1253
 
 
1254
 
    def get_format_string(self):
1255
 
        """See RepositoryFormat.get_format_string()."""
1256
 
        return "Bazaar-NG Repository format 7"
1257
 
 
1258
 
    def get_format_description(self):
1259
 
        """See RepositoryFormat.get_format_description()."""
1260
 
        return "Weave repository format 7"
1261
 
 
1262
 
    def _get_revision_store(self, repo_transport, control_files):
1263
 
        """See RepositoryFormat._get_revision_store()."""
1264
 
        return self._get_text_rev_store(repo_transport,
1265
 
                                        control_files,
1266
 
                                        'revision-store',
1267
 
                                        compressed=False,
1268
 
                                        prefixed=True,
1269
 
                                        )
1270
 
 
1271
 
    def _get_text_store(self, transport, control_files):
1272
 
        """See RepositoryFormat._get_text_store()."""
1273
 
        return self._get_versioned_file_store('weaves',
1274
 
                                              transport,
1275
 
                                              control_files)
1276
 
 
1277
 
    def initialize(self, a_bzrdir, shared=False):
1278
 
        """Create a weave repository.
1279
 
 
1280
 
        :param shared: If true the repository will be initialized as a shared
1281
 
                       repository.
1282
 
        """
1283
 
        from bzrlib.weavefile import write_weave_v5
1284
 
        from bzrlib.weave import Weave
1285
 
 
1286
 
        # Create an empty weave
1287
 
        sio = StringIO()
1288
 
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
1289
 
        empty_weave = sio.getvalue()
1290
 
 
1291
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
1292
 
        dirs = ['revision-store', 'weaves']
1293
 
        files = [('inventory.weave', StringIO(empty_weave)), 
1294
 
                 ]
1295
 
        utf8_files = [('format', self.get_format_string())]
1296
 
 
1297
 
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1298
 
        return self.open(a_bzrdir=a_bzrdir, _found=True)
1299
 
 
1300
 
    def open(self, a_bzrdir, _found=False, _override_transport=None):
1301
 
        """See RepositoryFormat.open().
1302
 
        
1303
 
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
1304
 
                                    repository at a slightly different url
1305
 
                                    than normal. I.e. during 'upgrade'.
1306
 
        """
1307
 
        if not _found:
1308
 
            format = RepositoryFormat.find_format(a_bzrdir)
1309
 
            assert format.__class__ ==  self.__class__
1310
 
        if _override_transport is not None:
1311
 
            repo_transport = _override_transport
1312
 
        else:
1313
 
            repo_transport = a_bzrdir.get_repository_transport(None)
1314
 
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
1315
 
        text_store = self._get_text_store(repo_transport, control_files)
1316
 
        control_store = self._get_control_store(repo_transport, control_files)
1317
 
        _revision_store = self._get_revision_store(repo_transport, control_files)
1318
 
        return MetaDirRepository(_format=self,
1319
 
                                 a_bzrdir=a_bzrdir,
1320
 
                                 control_files=control_files,
1321
 
                                 _revision_store=_revision_store,
1322
 
                                 control_store=control_store,
1323
 
                                 text_store=text_store)
1324
 
 
1325
 
 
1326
 
class RepositoryFormatKnit1(MetaDirRepositoryFormat):
1327
 
    """Bzr repository knit format 1.
1328
 
 
1329
 
    This repository format has:
1330
 
     - knits for file texts and inventory
1331
 
     - hash subdirectory based stores.
1332
 
     - knits for revisions and signatures
1333
 
     - TextStores for revisions and signatures.
1334
 
     - a format marker of its own
1335
 
     - an optional 'shared-storage' flag
1336
 
     - an optional 'no-working-trees' flag
1337
 
     - a LockDir lock
1338
 
 
1339
 
    This format was introduced in bzr 0.8.
1340
 
    """
1341
 
 
1342
 
    def _get_control_store(self, repo_transport, control_files):
1343
 
        """Return the control store for this repository."""
1344
 
        return VersionedFileStore(
1345
 
            repo_transport,
1346
 
            prefixed=False,
1347
 
            file_mode=control_files._file_mode,
1348
 
            versionedfile_class=KnitVersionedFile,
1349
 
            versionedfile_kwargs={'factory':KnitPlainFactory()},
1350
 
            )
1351
 
 
1352
 
    def get_format_string(self):
1353
 
        """See RepositoryFormat.get_format_string()."""
1354
 
        return "Bazaar-NG Knit Repository Format 1"
1355
 
 
1356
 
    def get_format_description(self):
1357
 
        """See RepositoryFormat.get_format_description()."""
1358
 
        return "Knit repository format 1"
1359
 
 
1360
 
    def _get_revision_store(self, repo_transport, control_files):
1361
 
        """See RepositoryFormat._get_revision_store()."""
1362
 
        from bzrlib.store.revision.knit import KnitRevisionStore
1363
 
        versioned_file_store = VersionedFileStore(
1364
 
            repo_transport,
1365
 
            file_mode=control_files._file_mode,
1366
 
            prefixed=False,
1367
 
            precious=True,
1368
 
            versionedfile_class=KnitVersionedFile,
1369
 
            versionedfile_kwargs={'delta':False, 'factory':KnitPlainFactory()},
1370
 
            escaped=True,
1371
 
            )
1372
 
        return KnitRevisionStore(versioned_file_store)
1373
 
 
1374
 
    def _get_text_store(self, transport, control_files):
1375
 
        """See RepositoryFormat._get_text_store()."""
1376
 
        return self._get_versioned_file_store('knits',
1377
 
                                              transport,
1378
 
                                              control_files,
1379
 
                                              versionedfile_class=KnitVersionedFile,
1380
 
                                              escaped=True)
1381
 
 
1382
 
    def initialize(self, a_bzrdir, shared=False):
1383
 
        """Create a knit format 1 repository.
1384
 
 
1385
 
        :param a_bzrdir: bzrdir to contain the new repository; must already
1386
 
            be initialized.
1387
 
        :param shared: If true the repository will be initialized as a shared
1388
 
                       repository.
1389
 
        """
1390
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
1391
 
        dirs = ['revision-store', 'knits']
1392
 
        files = []
1393
 
        utf8_files = [('format', self.get_format_string())]
1394
 
        
1395
 
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1396
 
        repo_transport = a_bzrdir.get_repository_transport(None)
1397
 
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
1398
 
        control_store = self._get_control_store(repo_transport, control_files)
1399
 
        transaction = bzrlib.transactions.WriteTransaction()
1400
 
        # trigger a write of the inventory store.
1401
 
        control_store.get_weave_or_empty('inventory', transaction)
1402
 
        _revision_store = self._get_revision_store(repo_transport, control_files)
1403
 
        _revision_store.has_revision_id('A', transaction)
1404
 
        _revision_store.get_signature_file(transaction)
1405
 
        return self.open(a_bzrdir=a_bzrdir, _found=True)
1406
 
 
1407
 
    def open(self, a_bzrdir, _found=False, _override_transport=None):
1408
 
        """See RepositoryFormat.open().
1409
 
        
1410
 
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
1411
 
                                    repository at a slightly different url
1412
 
                                    than normal. I.e. during 'upgrade'.
1413
 
        """
1414
 
        if not _found:
1415
 
            format = RepositoryFormat.find_format(a_bzrdir)
1416
 
            assert format.__class__ ==  self.__class__
1417
 
        if _override_transport is not None:
1418
 
            repo_transport = _override_transport
1419
 
        else:
1420
 
            repo_transport = a_bzrdir.get_repository_transport(None)
1421
 
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
1422
 
        text_store = self._get_text_store(repo_transport, control_files)
1423
 
        control_store = self._get_control_store(repo_transport, control_files)
1424
 
        _revision_store = self._get_revision_store(repo_transport, control_files)
1425
 
        return KnitRepository(_format=self,
1426
 
                              a_bzrdir=a_bzrdir,
1427
 
                              control_files=control_files,
1428
 
                              _revision_store=_revision_store,
1429
 
                              control_store=control_store,
1430
 
                              text_store=text_store)
1431
 
 
1432
 
 
1433
2255
# formats which have no format string are not discoverable
1434
 
# and not independently creatable, so are not registered.
1435
 
RepositoryFormat.register_format(RepositoryFormat7())
1436
 
_default_format = RepositoryFormatKnit1()
1437
 
RepositoryFormat.register_format(_default_format)
1438
 
RepositoryFormat.set_default_format(_default_format)
1439
 
_legacy_formats = [RepositoryFormat4(),
1440
 
                   RepositoryFormat5(),
1441
 
                   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
1442
2340
 
1443
2341
 
1444
2342
class InterRepository(InterObject):
1453
2351
    InterRepository.get(other).method_name(parameters).
1454
2352
    """
1455
2353
 
1456
 
    _optimisers = set()
 
2354
    _optimisers = []
1457
2355
    """The available optimised InterRepository types."""
1458
2356
 
1459
 
    @needs_write_lock
1460
 
    def copy_content(self, revision_id=None, basis=None):
1461
 
        """Make a complete copy of the content in self into destination.
1462
 
        
1463
 
        This is a destructive operation! Do not use it on existing 
1464
 
        repositories.
1465
 
 
1466
 
        :param revision_id: Only copy the content needed to construct
1467
 
                            revision_id and its parents.
1468
 
        :param basis: Copy the needed data preferentially from basis.
1469
 
        """
1470
 
        try:
1471
 
            self.target.set_make_working_trees(self.source.make_working_trees())
1472
 
        except NotImplementedError:
1473
 
            pass
1474
 
        # grab the basis available data
1475
 
        if basis is not None:
1476
 
            self.target.fetch(basis, revision_id=revision_id)
1477
 
        # but dont bother fetching if we have the needed data now.
1478
 
        if (revision_id not in (None, NULL_REVISION) and 
1479
 
            self.target.has_revision(revision_id)):
1480
 
            return
1481
 
        self.target.fetch(self.source, revision_id=revision_id)
1482
 
 
1483
 
    def _double_lock(self, lock_source, lock_target):
1484
 
        """Take out too locks, rolling back the first if the second throws."""
1485
 
        lock_source()
1486
 
        try:
1487
 
            lock_target()
1488
 
        except Exception:
1489
 
            # we want to ensure that we don't leave source locked by mistake.
1490
 
            # and any error on target should not confuse source.
1491
 
            self.source.unlock()
1492
 
            raise
1493
 
 
1494
 
    @needs_write_lock
1495
 
    def fetch(self, revision_id=None, pb=None):
 
2357
    def copy_content(self, revision_id=None):
 
2358
        raise NotImplementedError(self.copy_content)
 
2359
 
 
2360
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1496
2361
        """Fetch the content required to construct revision_id.
1497
2362
 
1498
 
        The content is copied from source to target.
 
2363
        The content is copied from self.source to self.target.
1499
2364
 
1500
2365
        :param revision_id: if None all content is copied, if NULL_REVISION no
1501
2366
                            content is copied.
1502
2367
        :param pb: optional progress bar to use for progress reports. If not
1503
2368
                   provided a default one will be created.
1504
2369
 
1505
 
        Returns the copied revision count and the failed revisions in a tuple:
1506
 
        (copied, failures).
1507
 
        """
1508
 
        from bzrlib.fetch import GenericRepoFetcher
1509
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1510
 
               self.source, self.source._format, self.target, self.target._format)
1511
 
        f = GenericRepoFetcher(to_repository=self.target,
1512
 
                               from_repository=self.source,
1513
 
                               last_revision=revision_id,
1514
 
                               pb=pb)
1515
 
        return f.count_copied, f.failed_revisions
1516
 
 
1517
 
    def lock_read(self):
1518
 
        """Take out a logical read lock.
1519
 
 
1520
 
        This will lock the source branch and the target branch. The source gets
1521
 
        a read lock and the target a read lock.
1522
 
        """
1523
 
        self._double_lock(self.source.lock_read, self.target.lock_read)
1524
 
 
1525
 
    def lock_write(self):
1526
 
        """Take out a logical write lock.
1527
 
 
1528
 
        This will lock the source branch and the target branch. The source gets
1529
 
        a read lock and the target a write lock.
1530
 
        """
1531
 
        self._double_lock(self.source.lock_read, self.target.lock_write)
1532
 
 
 
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()
 
2416
   
 
2417
    @deprecated_method(one_two)
1533
2418
    @needs_read_lock
1534
 
    def missing_revision_ids(self, revision_id=None):
 
2419
    def missing_revision_ids(self, revision_id=None, find_ghosts=True):
1535
2420
        """Return the revision ids that source has that target does not.
1536
2421
        
1537
2422
        These are returned in topological order.
1538
2423
 
1539
2424
        :param revision_id: only return revision ids included by this
1540
2425
                            revision_id.
1541
 
        """
 
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])
1542
2445
        # generic, possibly worst case, slow code path.
1543
2446
        target_ids = set(self.target.all_revision_ids())
1544
2447
        if revision_id is not None:
1545
2448
            source_ids = self.source.get_ancestry(revision_id)
1546
 
            assert source_ids[0] == None
 
2449
            if source_ids[0] is not None:
 
2450
                raise AssertionError()
1547
2451
            source_ids.pop(0)
1548
2452
        else:
1549
2453
            source_ids = self.source.all_revision_ids()
1550
2454
        result_set = set(source_ids).difference(target_ids)
1551
 
        # this may look like a no-op: its not. It preserves the ordering
1552
 
        # other_ids had while only returning the members from other_ids
1553
 
        # that we've decided we need.
1554
 
        return [rev_id for rev_id in source_ids if rev_id in result_set]
1555
 
 
1556
 
    def unlock(self):
1557
 
        """Release the locks on source and target."""
1558
 
        try:
1559
 
            self.target.unlock()
1560
 
        finally:
1561
 
            self.source.unlock()
1562
 
 
1563
 
 
1564
 
class InterWeaveRepo(InterRepository):
1565
 
    """Optimised code paths between Weave based repositories."""
1566
 
 
1567
 
    _matching_repo_format = RepositoryFormat7()
1568
 
    """Repository format for testing with."""
 
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")
 
2480
 
 
2481
 
 
2482
class InterSameDataRepository(InterRepository):
 
2483
    """Code for converting between repositories that represent the same data.
 
2484
    
 
2485
    Data format and model must match for this to work.
 
2486
    """
 
2487
 
 
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()
 
2497
 
 
2498
    @staticmethod
 
2499
    def is_compatible(source, target):
 
2500
        return InterRepository._same_model(source, target)
 
2501
 
 
2502
    @needs_write_lock
 
2503
    def copy_content(self, revision_id=None):
 
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.
 
2508
        
 
2509
        This is a destructive operation! Do not use it on existing 
 
2510
        repositories.
 
2511
 
 
2512
        :param revision_id: Only copy the content needed to construct
 
2513
                            revision_id and its parents.
 
2514
        """
 
2515
        try:
 
2516
            self.target.set_make_working_trees(self.source.make_working_trees())
 
2517
        except NotImplementedError:
 
2518
            pass
 
2519
        # but don't bother fetching if we have the needed data now.
 
2520
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
2521
            self.target.has_revision(revision_id)):
 
2522
            return
 
2523
        self.target.fetch(self.source, revision_id=revision_id)
 
2524
 
 
2525
    @needs_write_lock
 
2526
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2527
        """See InterRepository.fetch()."""
 
2528
        from bzrlib.fetch import RepoFetcher
 
2529
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2530
               self.source, self.source._format, self.target,
 
2531
               self.target._format)
 
2532
        f = RepoFetcher(to_repository=self.target,
 
2533
                               from_repository=self.source,
 
2534
                               last_revision=revision_id,
 
2535
                               pb=pb, find_ghosts=find_ghosts)
 
2536
        return f.count_copied, f.failed_revisions
 
2537
 
 
2538
 
 
2539
class InterWeaveRepo(InterSameDataRepository):
 
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
    """
 
2545
 
 
2546
    @classmethod
 
2547
    def _get_repo_format_to_test(self):
 
2548
        from bzrlib.repofmt import weaverepo
 
2549
        return weaverepo.RepositoryFormat7()
1569
2550
 
1570
2551
    @staticmethod
1571
2552
    def is_compatible(source, target):
1572
2553
        """Be compatible with known Weave formats.
1573
2554
        
1574
 
        We dont test for the stores being of specific types becase that
 
2555
        We don't test for the stores being of specific types because that
1575
2556
        could lead to confusing results, and there is no need to be 
1576
2557
        overly general.
1577
2558
        """
 
2559
        from bzrlib.repofmt.weaverepo import (
 
2560
                RepositoryFormat5,
 
2561
                RepositoryFormat6,
 
2562
                RepositoryFormat7,
 
2563
                )
1578
2564
        try:
1579
2565
            return (isinstance(source._format, (RepositoryFormat5,
1580
2566
                                                RepositoryFormat6,
1586
2572
            return False
1587
2573
    
1588
2574
    @needs_write_lock
1589
 
    def copy_content(self, revision_id=None, basis=None):
 
2575
    def copy_content(self, revision_id=None):
1590
2576
        """See InterRepository.copy_content()."""
1591
2577
        # weave specific optimised path:
1592
 
        if basis is not None:
1593
 
            # copy the basis in, then fetch remaining data.
1594
 
            basis.copy_content_into(self.target, revision_id)
1595
 
            # the basis copy_content_into could misset 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()
1596
2585
            try:
1597
 
                self.target.set_make_working_trees(self.source.make_working_trees())
1598
 
            except NotImplementedError:
1599
 
                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:
1600
2604
            self.target.fetch(self.source, revision_id=revision_id)
1601
 
        else:
1602
 
            try:
1603
 
                self.target.set_make_working_trees(self.source.make_working_trees())
1604
 
            except NotImplementedError:
1605
 
                pass
1606
 
            # FIXME do not peek!
1607
 
            if self.source.control_files._transport.listable():
1608
 
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
1609
 
                try:
1610
 
                    self.target.weave_store.copy_all_ids(
1611
 
                        self.source.weave_store,
1612
 
                        pb=pb,
1613
 
                        from_transaction=self.source.get_transaction(),
1614
 
                        to_transaction=self.target.get_transaction())
1615
 
                    pb.update('copying inventory', 0, 1)
1616
 
                    self.target.control_weaves.copy_multi(
1617
 
                        self.source.control_weaves, ['inventory'],
1618
 
                        from_transaction=self.source.get_transaction(),
1619
 
                        to_transaction=self.target.get_transaction())
1620
 
                    self.target._revision_store.text_store.copy_all_ids(
1621
 
                        self.source._revision_store.text_store,
1622
 
                        pb=pb)
1623
 
                finally:
1624
 
                    pb.finished()
1625
 
            else:
1626
 
                self.target.fetch(self.source, revision_id=revision_id)
1627
2605
 
1628
2606
    @needs_write_lock
1629
 
    def fetch(self, revision_id=None, pb=None):
 
2607
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1630
2608
        """See InterRepository.fetch()."""
1631
 
        from bzrlib.fetch import GenericRepoFetcher
 
2609
        from bzrlib.fetch import RepoFetcher
1632
2610
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1633
2611
               self.source, self.source._format, self.target, self.target._format)
1634
 
        f = GenericRepoFetcher(to_repository=self.target,
 
2612
        f = RepoFetcher(to_repository=self.target,
1635
2613
                               from_repository=self.source,
1636
2614
                               last_revision=revision_id,
1637
 
                               pb=pb)
 
2615
                               pb=pb, find_ghosts=find_ghosts)
1638
2616
        return f.count_copied, f.failed_revisions
1639
2617
 
1640
2618
    @needs_read_lock
1641
 
    def missing_revision_ids(self, revision_id=None):
 
2619
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1642
2620
        """See InterRepository.missing_revision_ids()."""
1643
2621
        # we want all revisions to satisfy revision_id in source.
1644
 
        # but we dont want to stat every file here and there.
 
2622
        # but we don't want to stat every file here and there.
1645
2623
        # we want then, all revisions other needs to satisfy revision_id 
1646
2624
        # checked, but not those that we have locally.
1647
2625
        # so the first thing is to get a subset of the revisions to 
1653
2631
        # - RBC 20060209
1654
2632
        if revision_id is not None:
1655
2633
            source_ids = self.source.get_ancestry(revision_id)
1656
 
            assert source_ids[0] == None
 
2634
            if source_ids[0] is not None:
 
2635
                raise AssertionError()
1657
2636
            source_ids.pop(0)
1658
2637
        else:
1659
2638
            source_ids = self.source._all_possible_ids()
1660
2639
        source_ids_set = set(source_ids)
1661
2640
        # source_ids is the worst possible case we may need to pull.
1662
2641
        # now we want to filter source_ids against what we actually
1663
 
        # have in target, but dont try to check for existence where we know
 
2642
        # have in target, but don't try to check for existence where we know
1664
2643
        # we do not have a revision as that would be pointless.
1665
2644
        target_ids = set(self.target._all_possible_ids())
1666
2645
        possibly_present_revisions = target_ids.intersection(source_ids_set)
1667
 
        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))
1668
2648
        required_revisions = source_ids_set.difference(actually_present_revisions)
1669
 
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1670
2649
        if revision_id is not None:
1671
2650
            # we used get_ancestry to determine source_ids then we are assured all
1672
2651
            # revisions referenced are present as they are installed in topological order.
1673
2652
            # and the tip revision was validated by get_ancestry.
1674
 
            return required_topo_revisions
 
2653
            result_set = required_revisions
1675
2654
        else:
1676
2655
            # if we just grabbed the possibly available ids, then 
1677
2656
            # we only have an estimate of whats available and need to validate
1678
2657
            # that against the revision records.
1679
 
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
1680
 
 
1681
 
 
1682
 
class InterKnitRepo(InterRepository):
 
2658
            result_set = set(
 
2659
                self.source._eliminate_revisions_not_present(required_revisions))
 
2660
        return self.source.revision_ids_to_search_result(result_set)
 
2661
 
 
2662
 
 
2663
class InterKnitRepo(InterSameDataRepository):
1683
2664
    """Optimised code paths between Knit based repositories."""
1684
2665
 
1685
 
    _matching_repo_format = RepositoryFormatKnit1()
1686
 
    """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()
1687
2670
 
1688
2671
    @staticmethod
1689
2672
    def is_compatible(source, target):
1690
2673
        """Be compatible with known Knit formats.
1691
2674
        
1692
 
        We dont test for the stores being of specific types becase that
 
2675
        We don't test for the stores being of specific types because that
1693
2676
        could lead to confusing results, and there is no need to be 
1694
2677
        overly general.
1695
2678
        """
 
2679
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
1696
2680
        try:
1697
 
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
1698
 
                    isinstance(target._format, (RepositoryFormatKnit1)))
 
2681
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
 
2682
                isinstance(target._format, RepositoryFormatKnit))
1699
2683
        except AttributeError:
1700
2684
            return False
 
2685
        return are_knits and InterRepository._same_model(source, target)
1701
2686
 
1702
2687
    @needs_write_lock
1703
 
    def fetch(self, revision_id=None, pb=None):
 
2688
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1704
2689
        """See InterRepository.fetch()."""
1705
 
        from bzrlib.fetch import KnitRepoFetcher
 
2690
        from bzrlib.fetch import RepoFetcher
1706
2691
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1707
2692
               self.source, self.source._format, self.target, self.target._format)
1708
 
        f = KnitRepoFetcher(to_repository=self.target,
 
2693
        f = RepoFetcher(to_repository=self.target,
1709
2694
                            from_repository=self.source,
1710
2695
                            last_revision=revision_id,
1711
 
                            pb=pb)
 
2696
                            pb=pb, find_ghosts=find_ghosts)
1712
2697
        return f.count_copied, f.failed_revisions
1713
2698
 
1714
2699
    @needs_read_lock
1715
 
    def missing_revision_ids(self, revision_id=None):
 
2700
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1716
2701
        """See InterRepository.missing_revision_ids()."""
1717
2702
        if revision_id is not None:
1718
2703
            source_ids = self.source.get_ancestry(revision_id)
1719
 
            assert source_ids[0] == None
 
2704
            if source_ids[0] is not None:
 
2705
                raise AssertionError()
1720
2706
            source_ids.pop(0)
1721
2707
        else:
1722
 
            source_ids = self.source._all_possible_ids()
 
2708
            source_ids = self.source.all_revision_ids()
1723
2709
        source_ids_set = set(source_ids)
1724
2710
        # source_ids is the worst possible case we may need to pull.
1725
2711
        # now we want to filter source_ids against what we actually
1726
 
        # have in target, but dont try to check for existence where we know
 
2712
        # have in target, but don't try to check for existence where we know
1727
2713
        # we do not have a revision as that would be pointless.
1728
 
        target_ids = set(self.target._all_possible_ids())
 
2714
        target_ids = set(self.target.all_revision_ids())
1729
2715
        possibly_present_revisions = target_ids.intersection(source_ids_set)
1730
 
        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))
1731
2718
        required_revisions = source_ids_set.difference(actually_present_revisions)
1732
 
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1733
2719
        if revision_id is not None:
1734
2720
            # we used get_ancestry to determine source_ids then we are assured all
1735
2721
            # revisions referenced are present as they are installed in topological order.
1736
2722
            # and the tip revision was validated by get_ancestry.
1737
 
            return required_topo_revisions
 
2723
            result_set = required_revisions
1738
2724
        else:
1739
2725
            # if we just grabbed the possibly available ids, then 
1740
2726
            # we only have an estimate of whats available and need to validate
1741
2727
            # that against the revision records.
1742
 
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
1743
 
 
 
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)
 
2857
 
 
2858
 
 
2859
class InterModel1and2(InterRepository):
 
2860
 
 
2861
    @classmethod
 
2862
    def _get_repo_format_to_test(self):
 
2863
        return None
 
2864
 
 
2865
    @staticmethod
 
2866
    def is_compatible(source, target):
 
2867
        if not source.supports_rich_root() and target.supports_rich_root():
 
2868
            return True
 
2869
        else:
 
2870
            return False
 
2871
 
 
2872
    @needs_write_lock
 
2873
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2874
        """See InterRepository.fetch()."""
 
2875
        from bzrlib.fetch import Model1toKnit2Fetcher
 
2876
        f = Model1toKnit2Fetcher(to_repository=self.target,
 
2877
                                 from_repository=self.source,
 
2878
                                 last_revision=revision_id,
 
2879
                                 pb=pb, find_ghosts=find_ghosts)
 
2880
        return f.count_copied, f.failed_revisions
 
2881
 
 
2882
    @needs_write_lock
 
2883
    def copy_content(self, revision_id=None):
 
2884
        """Make a complete copy of the content in self into destination.
 
2885
        
 
2886
        This is a destructive operation! Do not use it on existing 
 
2887
        repositories.
 
2888
 
 
2889
        :param revision_id: Only copy the content needed to construct
 
2890
                            revision_id and its parents.
 
2891
        """
 
2892
        try:
 
2893
            self.target.set_make_working_trees(self.source.make_working_trees())
 
2894
        except NotImplementedError:
 
2895
            pass
 
2896
        # but don't bother fetching if we have the needed data now.
 
2897
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
2898
            self.target.has_revision(revision_id)):
 
2899
            return
 
2900
        self.target.fetch(self.source, revision_id=revision_id)
 
2901
 
 
2902
 
 
2903
class InterKnit1and2(InterKnitRepo):
 
2904
 
 
2905
    @classmethod
 
2906
    def _get_repo_format_to_test(self):
 
2907
        return None
 
2908
 
 
2909
    @staticmethod
 
2910
    def is_compatible(source, target):
 
2911
        """Be compatible with Knit1 source and Knit3 target"""
 
2912
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit3
 
2913
        try:
 
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))
 
2934
        except AttributeError:
 
2935
            return False
 
2936
 
 
2937
    @needs_write_lock
 
2938
    def fetch(self, revision_id=None, pb=None, find_ghosts=False):
 
2939
        """See InterRepository.fetch()."""
 
2940
        from bzrlib.fetch import Knit1to2Fetcher
 
2941
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2942
               self.source, self.source._format, self.target, 
 
2943
               self.target._format)
 
2944
        f = Knit1to2Fetcher(to_repository=self.target,
 
2945
                            from_repository=self.source,
 
2946
                            last_revision=revision_id,
 
2947
                            pb=pb, find_ghosts=find_ghosts)
 
2948
        return f.count_copied, f.failed_revisions
 
2949
 
 
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)
 
3072
InterRepository.register_optimiser(InterSameDataRepository)
1744
3073
InterRepository.register_optimiser(InterWeaveRepo)
1745
3074
InterRepository.register_optimiser(InterKnitRepo)
1746
 
 
1747
 
 
1748
 
class RepositoryTestProviderAdapter(object):
1749
 
    """A tool to generate a suite testing multiple repository formats at once.
1750
 
 
1751
 
    This is done by copying the test once for each transport and injecting
1752
 
    the transport_server, transport_readonly_server, and bzrdir_format and
1753
 
    repository_format classes into each copy. Each copy is also given a new id()
1754
 
    to make it easy to identify.
1755
 
    """
1756
 
 
1757
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1758
 
        self._transport_server = transport_server
1759
 
        self._transport_readonly_server = transport_readonly_server
1760
 
        self._formats = formats
1761
 
    
1762
 
    def adapt(self, test):
1763
 
        result = TestSuite()
1764
 
        for repository_format, bzrdir_format in self._formats:
1765
 
            new_test = deepcopy(test)
1766
 
            new_test.transport_server = self._transport_server
1767
 
            new_test.transport_readonly_server = self._transport_readonly_server
1768
 
            new_test.bzrdir_format = bzrdir_format
1769
 
            new_test.repository_format = repository_format
1770
 
            def make_new_test_id():
1771
 
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
1772
 
                return lambda: new_id
1773
 
            new_test.id = make_new_test_id()
1774
 
            result.addTest(new_test)
1775
 
        return result
1776
 
 
1777
 
 
1778
 
class InterRepositoryTestProviderAdapter(object):
1779
 
    """A tool to generate a suite testing multiple inter repository formats.
1780
 
 
1781
 
    This is done by copying the test once for each interrepo provider and injecting
1782
 
    the transport_server, transport_readonly_server, repository_format and 
1783
 
    repository_to_format classes into each copy.
1784
 
    Each copy is also given a new id() to make it easy to identify.
1785
 
    """
1786
 
 
1787
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1788
 
        self._transport_server = transport_server
1789
 
        self._transport_readonly_server = transport_readonly_server
1790
 
        self._formats = formats
1791
 
    
1792
 
    def adapt(self, test):
1793
 
        result = TestSuite()
1794
 
        for interrepo_class, repository_format, repository_format_to in self._formats:
1795
 
            new_test = deepcopy(test)
1796
 
            new_test.transport_server = self._transport_server
1797
 
            new_test.transport_readonly_server = self._transport_readonly_server
1798
 
            new_test.interrepo_class = interrepo_class
1799
 
            new_test.repository_format = repository_format
1800
 
            new_test.repository_format_to = repository_format_to
1801
 
            def make_new_test_id():
1802
 
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
1803
 
                return lambda: new_id
1804
 
            new_test.id = make_new_test_id()
1805
 
            result.addTest(new_test)
1806
 
        return result
1807
 
 
1808
 
    @staticmethod
1809
 
    def default_test_list():
1810
 
        """Generate the default list of interrepo permutations to test."""
1811
 
        result = []
1812
 
        # test the default InterRepository between format 6 and the current 
1813
 
        # default format.
1814
 
        # XXX: robertc 20060220 reinstate this when there are two supported
1815
 
        # formats which do not have an optimal code path between them.
1816
 
        result.append((InterRepository,
1817
 
                       RepositoryFormat6(),
1818
 
                       RepositoryFormatKnit1()))
1819
 
        for optimiser in InterRepository._optimisers:
1820
 
            result.append((optimiser,
1821
 
                           optimiser._matching_repo_format,
1822
 
                           optimiser._matching_repo_format
1823
 
                           ))
1824
 
        # if there are specific combinations we want to use, we can add them 
1825
 
        # here.
1826
 
        return result
 
3075
InterRepository.register_optimiser(InterModel1and2)
 
3076
InterRepository.register_optimiser(InterKnit1and2)
 
3077
InterRepository.register_optimiser(InterPackRepo)
 
3078
InterRepository.register_optimiser(InterOtherToRemote)
 
3079
InterRepository.register_optimiser(InterRemoteToOther)
1827
3080
 
1828
3081
 
1829
3082
class CopyConverter(object):
1855
3108
        self.step('Moving repository to repository.backup')
1856
3109
        self.repo_dir.transport.move('repository', 'repository.backup')
1857
3110
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
 
3111
        repo._format.check_conversion_target(self.target_format)
1858
3112
        self.source_repo = repo._format.open(self.repo_dir,
1859
3113
            _found=True,
1860
3114
            _override_transport=backup_transport)
1877
3131
        self.pb.update(message, self.count, self.total)
1878
3132
 
1879
3133
 
1880
 
class CommitBuilder(object):
1881
 
    """Provides an interface to build up a commit.
1882
 
 
1883
 
    This allows describing a tree to be committed without needing to 
1884
 
    know the internals of the format of the repository.
1885
 
    """
1886
 
    def __init__(self, repository, parents, config, timestamp=None, 
1887
 
                 timezone=None, committer=None, revprops=None, 
1888
 
                 revision_id=None):
1889
 
        """Initiate a CommitBuilder.
1890
 
 
1891
 
        :param repository: Repository to commit to.
1892
 
        :param parents: Revision ids of the parents of the new revision.
1893
 
        :param config: Configuration to use.
1894
 
        :param timestamp: Optional timestamp recorded for commit.
1895
 
        :param timezone: Optional timezone for timestamp.
1896
 
        :param committer: Optional committer to set for commit.
1897
 
        :param revprops: Optional dictionary of revision properties.
1898
 
        :param revision_id: Optional revision id.
1899
 
        """
1900
 
        self._config = config
1901
 
 
1902
 
        if committer is None:
1903
 
            self._committer = self._config.username()
1904
 
        else:
1905
 
            assert isinstance(committer, basestring), type(committer)
1906
 
            self._committer = committer
1907
 
 
1908
 
        self.new_inventory = Inventory()
1909
 
        self._new_revision_id = revision_id
1910
 
        self.parents = parents
1911
 
        self.repository = repository
1912
 
 
1913
 
        self._revprops = {}
1914
 
        if revprops is not None:
1915
 
            self._revprops.update(revprops)
1916
 
 
1917
 
        if timestamp is None:
1918
 
            self._timestamp = time.time()
1919
 
        else:
1920
 
            self._timestamp = long(timestamp)
1921
 
 
1922
 
        if timezone is None:
1923
 
            self._timezone = local_time_offset()
1924
 
        else:
1925
 
            self._timezone = int(timezone)
1926
 
 
1927
 
        self._generate_revision_if_needed()
1928
 
 
1929
 
    def commit(self, message):
1930
 
        """Make the actual commit.
1931
 
 
1932
 
        :return: The revision id of the recorded revision.
1933
 
        """
1934
 
        rev = Revision(timestamp=self._timestamp,
1935
 
                       timezone=self._timezone,
1936
 
                       committer=self._committer,
1937
 
                       message=message,
1938
 
                       inventory_sha1=self.inv_sha1,
1939
 
                       revision_id=self._new_revision_id,
1940
 
                       properties=self._revprops)
1941
 
        rev.parent_ids = self.parents
1942
 
        self.repository.add_revision(self._new_revision_id, rev, 
1943
 
            self.new_inventory, self._config)
1944
 
        return self._new_revision_id
1945
 
 
1946
 
    def finish_inventory(self):
1947
 
        """Tell the builder that the inventory is finished."""
1948
 
        self.new_inventory.revision_id = self._new_revision_id
1949
 
        self.inv_sha1 = self.repository.add_inventory(
1950
 
            self._new_revision_id,
1951
 
            self.new_inventory,
1952
 
            self.parents
1953
 
            )
1954
 
 
1955
 
    def _gen_revision_id(self):
1956
 
        """Return new revision-id."""
1957
 
        s = '%s-%s-' % (self._config.user_email(), 
1958
 
                        compact_date(self._timestamp))
1959
 
        s += hexlify(rand_bytes(8))
1960
 
        return s
1961
 
 
1962
 
    def _generate_revision_if_needed(self):
1963
 
        """Create a revision id if None was supplied.
1964
 
        
1965
 
        If the repository can not support user-specified revision ids
1966
 
        they should override this function and raise UnsupportedOperation
1967
 
        if _new_revision_id is not None.
1968
 
 
1969
 
        :raises: UnsupportedOperation
1970
 
        """
1971
 
        if self._new_revision_id is None:
1972
 
            self._new_revision_id = self._gen_revision_id()
1973
 
 
1974
 
    def record_entry_contents(self, ie, parent_invs, path, tree):
1975
 
        """Record the content of ie from tree into the commit if needed.
1976
 
 
1977
 
        :param ie: An inventory entry present in the commit.
1978
 
        :param parent_invs: The inventories of the parent revisions of the
1979
 
            commit.
1980
 
        :param path: The path the entry is at in the tree.
1981
 
        :param tree: The tree which contains this entry and should be used to 
1982
 
        obtain content.
1983
 
        """
1984
 
        self.new_inventory.add(ie)
1985
 
 
1986
 
        # ie.revision is always None if the InventoryEntry is considered
1987
 
        # for committing. ie.snapshot will record the correct revision 
1988
 
        # which may be the sole parent if it is untouched.
1989
 
        if ie.revision is not None:
1990
 
            return
1991
 
        previous_entries = ie.find_previous_heads(
1992
 
            parent_invs,
1993
 
            self.repository.weave_store,
1994
 
            self.repository.get_transaction())
1995
 
        # we are creating a new revision for ie in the history store
1996
 
        # and inventory.
1997
 
        ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
1998
 
 
1999
 
    def modified_directory(self, file_id, file_parents):
2000
 
        """Record the presence of a symbolic link.
2001
 
 
2002
 
        :param file_id: The file_id of the link to record.
2003
 
        :param file_parents: The per-file parent revision ids.
2004
 
        """
2005
 
        self._add_text_to_weave(file_id, [], file_parents.keys())
2006
 
    
2007
 
    def modified_file_text(self, file_id, file_parents,
2008
 
                           get_content_byte_lines, text_sha1=None,
2009
 
                           text_size=None):
2010
 
        """Record the text of file file_id
2011
 
 
2012
 
        :param file_id: The file_id of the file to record the text of.
2013
 
        :param file_parents: The per-file parent revision ids.
2014
 
        :param get_content_byte_lines: A callable which will return the byte
2015
 
            lines for the file.
2016
 
        :param text_sha1: Optional SHA1 of the file contents.
2017
 
        :param text_size: Optional size of the file contents.
2018
 
        """
2019
 
        mutter('storing text of file {%s} in revision {%s} into %r',
2020
 
               file_id, self._new_revision_id, self.repository.weave_store)
2021
 
        # special case to avoid diffing on renames or 
2022
 
        # reparenting
2023
 
        if (len(file_parents) == 1
2024
 
            and text_sha1 == file_parents.values()[0].text_sha1
2025
 
            and text_size == file_parents.values()[0].text_size):
2026
 
            previous_ie = file_parents.values()[0]
2027
 
            versionedfile = self.repository.weave_store.get_weave(file_id, 
2028
 
                self.repository.get_transaction())
2029
 
            versionedfile.clone_text(self._new_revision_id, 
2030
 
                previous_ie.revision, file_parents.keys())
2031
 
            return text_sha1, text_size
2032
 
        else:
2033
 
            new_lines = get_content_byte_lines()
2034
 
            # TODO: Rather than invoking sha_strings here, _add_text_to_weave
2035
 
            # should return the SHA1 and size
2036
 
            self._add_text_to_weave(file_id, new_lines, file_parents.keys())
2037
 
            return bzrlib.osutils.sha_strings(new_lines), \
2038
 
                sum(map(len, new_lines))
2039
 
 
2040
 
    def modified_link(self, file_id, file_parents, link_target):
2041
 
        """Record the presence of a symbolic link.
2042
 
 
2043
 
        :param file_id: The file_id of the link to record.
2044
 
        :param file_parents: The per-file parent revision ids.
2045
 
        :param link_target: Target location of this link.
2046
 
        """
2047
 
        self._add_text_to_weave(file_id, [], file_parents.keys())
2048
 
 
2049
 
    def _add_text_to_weave(self, file_id, new_lines, parents):
2050
 
        versionedfile = self.repository.weave_store.get_weave_or_empty(
2051
 
            file_id, self.repository.get_transaction())
2052
 
        versionedfile.add_lines(self._new_revision_id, parents, new_lines)
2053
 
        versionedfile.clear_cache()
2054
 
 
2055
 
 
2056
 
# Copied from xml.sax.saxutils
 
3134
_unescape_map = {
 
3135
    'apos':"'",
 
3136
    'quot':'"',
 
3137
    'amp':'&',
 
3138
    'lt':'<',
 
3139
    'gt':'>'
 
3140
}
 
3141
 
 
3142
 
 
3143
def _unescaper(match, _map=_unescape_map):
 
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')
 
3151
 
 
3152
 
 
3153
_unescape_re = None
 
3154
 
 
3155
 
2057
3156
def _unescape_xml(data):
2058
 
    """Unescape &amp;, &lt;, and &gt; in a string of data.
2059
 
    """
2060
 
    data = data.replace("&lt;", "<")
2061
 
    data = data.replace("&gt;", ">")
2062
 
    # must do ampersand last
2063
 
    return data.replace("&amp;", "&")
 
3157
    """Unescape predefined XML entities in a string of data."""
 
3158
    global _unescape_re
 
3159
    if _unescape_re is None:
 
3160
        _unescape_re = re.compile('\&([^;]*);')
 
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