← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Vincent Ladeuil
  • Date: 2010-10-26 08:08:23 UTC
  • mfrom: (5514.1.1 665100-content-type)
  • mto: This revision was merged to the branch mainline in revision 5516.
  • Revision ID: v.ladeuil+lp@free.fr-20101026080823-3wggo03b7cpn9908
Correctly set the Content-Type header when POSTing http requests

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-2010 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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from binascii import hexlify
18
 
from copy import deepcopy
19
 
from cStringIO import StringIO
 
17
from bzrlib.lazy_import import lazy_import
 
18
lazy_import(globals(), """
 
19
import cStringIO
20
20
import re
21
21
import time
22
 
from unittest import TestSuite
23
 
 
24
 
from bzrlib import bzrdir, check, delta, gpg, errors, xml5, ui, transactions, osutils
25
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
26
 
from bzrlib.errors import InvalidRevisionId
27
 
from bzrlib.graph import Graph
 
22
 
 
23
from bzrlib import (
 
24
    bzrdir,
 
25
    check,
 
26
    chk_map,
 
27
    config,
 
28
    controldir,
 
29
    debug,
 
30
    fetch as _mod_fetch,
 
31
    fifo_cache,
 
32
    generate_ids,
 
33
    gpg,
 
34
    graph,
 
35
    inventory,
 
36
    inventory_delta,
 
37
    lazy_regex,
 
38
    lockable_files,
 
39
    lockdir,
 
40
    lru_cache,
 
41
    osutils,
 
42
    pyutils,
 
43
    revision as _mod_revision,
 
44
    static_tuple,
 
45
    symbol_versioning,
 
46
    trace,
 
47
    tsort,
 
48
    versionedfile,
 
49
    )
 
50
from bzrlib.bundle import serializer
 
51
from bzrlib.revisiontree import RevisionTree
 
52
from bzrlib.store.versioned import VersionedFileStore
 
53
from bzrlib.testament import Testament
 
54
""")
 
55
 
 
56
import sys
 
57
from bzrlib import (
 
58
    errors,
 
59
    registry,
 
60
    ui,
 
61
    )
 
62
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
28
63
from bzrlib.inter import InterObject
29
 
from bzrlib.inventory import Inventory
30
 
from bzrlib.knit import KnitVersionedFile, KnitPlainFactory
31
 
from bzrlib.lockable_files import LockableFiles, TransportLock
32
 
from bzrlib.lockdir import LockDir
33
 
from bzrlib.osutils import (safe_unicode, rand_bytes, compact_date, 
34
 
                            local_time_offset)
35
 
from bzrlib.revision import NULL_REVISION, Revision
36
 
from bzrlib.store.versioned import VersionedFileStore, WeaveStore
37
 
from bzrlib.store.text import TextStore
38
 
from bzrlib.symbol_versioning import (deprecated_method,
39
 
        zero_nine, 
40
 
        )
41
 
from bzrlib.trace import mutter, note
42
 
from bzrlib.tree import RevisionTree, EmptyTree
43
 
from bzrlib.tsort import topo_sort
44
 
from bzrlib.testament import Testament
45
 
from bzrlib.tree import EmptyTree
46
 
from bzrlib.weave import WeaveFile
47
 
 
48
 
 
49
 
class Repository(object):
 
64
from bzrlib.inventory import (
 
65
    Inventory,
 
66
    InventoryDirectory,
 
67
    ROOT_ID,
 
68
    entry_factory,
 
69
    )
 
70
from bzrlib.recordcounter import RecordCounter
 
71
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
72
from bzrlib.trace import (
 
73
    log_exception_quietly, note, mutter, mutter_callsite, warning)
 
74
 
 
75
 
 
76
# Old formats display a warning, but only once
 
77
_deprecation_warning_done = False
 
78
 
 
79
 
 
80
class IsInWriteGroupError(errors.InternalBzrError):
 
81
 
 
82
    _fmt = "May not refresh_data of repo %(repo)s while in a write group."
 
83
 
 
84
    def __init__(self, repo):
 
85
        errors.InternalBzrError.__init__(self, repo=repo)
 
86
 
 
87
 
 
88
class CommitBuilder(object):
 
89
    """Provides an interface to build up a commit.
 
90
 
 
91
    This allows describing a tree to be committed without needing to
 
92
    know the internals of the format of the repository.
 
93
    """
 
94
 
 
95
    # all clients should supply tree roots.
 
96
    record_root_entry = True
 
97
    # the default CommitBuilder does not manage trees whose root is versioned.
 
98
    _versioned_root = False
 
99
 
 
100
    def __init__(self, repository, parents, config, timestamp=None,
 
101
                 timezone=None, committer=None, revprops=None,
 
102
                 revision_id=None):
 
103
        """Initiate a CommitBuilder.
 
104
 
 
105
        :param repository: Repository to commit to.
 
106
        :param parents: Revision ids of the parents of the new revision.
 
107
        :param config: Configuration to use.
 
108
        :param timestamp: Optional timestamp recorded for commit.
 
109
        :param timezone: Optional timezone for timestamp.
 
110
        :param committer: Optional committer to set for commit.
 
111
        :param revprops: Optional dictionary of revision properties.
 
112
        :param revision_id: Optional revision id.
 
113
        """
 
114
        self._config = config
 
115
 
 
116
        if committer is None:
 
117
            self._committer = self._config.username()
 
118
        elif not isinstance(committer, unicode):
 
119
            self._committer = committer.decode() # throw if non-ascii
 
120
        else:
 
121
            self._committer = committer
 
122
 
 
123
        self.new_inventory = Inventory(None)
 
124
        self._new_revision_id = revision_id
 
125
        self.parents = parents
 
126
        self.repository = repository
 
127
 
 
128
        self._revprops = {}
 
129
        if revprops is not None:
 
130
            self._validate_revprops(revprops)
 
131
            self._revprops.update(revprops)
 
132
 
 
133
        if timestamp is None:
 
134
            timestamp = time.time()
 
135
        # Restrict resolution to 1ms
 
136
        self._timestamp = round(timestamp, 3)
 
137
 
 
138
        if timezone is None:
 
139
            self._timezone = osutils.local_time_offset()
 
140
        else:
 
141
            self._timezone = int(timezone)
 
142
 
 
143
        self._generate_revision_if_needed()
 
144
        self.__heads = graph.HeadsCache(repository.get_graph()).heads
 
145
        self._basis_delta = []
 
146
        # API compatibility, older code that used CommitBuilder did not call
 
147
        # .record_delete(), which means the delta that is computed would not be
 
148
        # valid. Callers that will call record_delete() should call
 
149
        # .will_record_deletes() to indicate that.
 
150
        self._recording_deletes = False
 
151
        # memo'd check for no-op commits.
 
152
        self._any_changes = False
 
153
 
 
154
    def any_changes(self):
 
155
        """Return True if any entries were changed.
 
156
        
 
157
        This includes merge-only changes. It is the core for the --unchanged
 
158
        detection in commit.
 
159
 
 
160
        :return: True if any changes have occured.
 
161
        """
 
162
        return self._any_changes
 
163
 
 
164
    def _validate_unicode_text(self, text, context):
 
165
        """Verify things like commit messages don't have bogus characters."""
 
166
        if '\r' in text:
 
167
            raise ValueError('Invalid value for %s: %r' % (context, text))
 
168
 
 
169
    def _validate_revprops(self, revprops):
 
170
        for key, value in revprops.iteritems():
 
171
            # We know that the XML serializers do not round trip '\r'
 
172
            # correctly, so refuse to accept them
 
173
            if not isinstance(value, basestring):
 
174
                raise ValueError('revision property (%s) is not a valid'
 
175
                                 ' (unicode) string: %r' % (key, value))
 
176
            self._validate_unicode_text(value,
 
177
                                        'revision property (%s)' % (key,))
 
178
 
 
179
    def commit(self, message):
 
180
        """Make the actual commit.
 
181
 
 
182
        :return: The revision id of the recorded revision.
 
183
        """
 
184
        self._validate_unicode_text(message, 'commit message')
 
185
        rev = _mod_revision.Revision(
 
186
                       timestamp=self._timestamp,
 
187
                       timezone=self._timezone,
 
188
                       committer=self._committer,
 
189
                       message=message,
 
190
                       inventory_sha1=self.inv_sha1,
 
191
                       revision_id=self._new_revision_id,
 
192
                       properties=self._revprops)
 
193
        rev.parent_ids = self.parents
 
194
        self.repository.add_revision(self._new_revision_id, rev,
 
195
            self.new_inventory, self._config)
 
196
        self.repository.commit_write_group()
 
197
        return self._new_revision_id
 
198
 
 
199
    def abort(self):
 
200
        """Abort the commit that is being built.
 
201
        """
 
202
        self.repository.abort_write_group()
 
203
 
 
204
    def revision_tree(self):
 
205
        """Return the tree that was just committed.
 
206
 
 
207
        After calling commit() this can be called to get a RevisionTree
 
208
        representing the newly committed tree. This is preferred to
 
209
        calling Repository.revision_tree() because that may require
 
210
        deserializing the inventory, while we already have a copy in
 
211
        memory.
 
212
        """
 
213
        if self.new_inventory is None:
 
214
            self.new_inventory = self.repository.get_inventory(
 
215
                self._new_revision_id)
 
216
        return RevisionTree(self.repository, self.new_inventory,
 
217
            self._new_revision_id)
 
218
 
 
219
    def finish_inventory(self):
 
220
        """Tell the builder that the inventory is finished.
 
221
 
 
222
        :return: The inventory id in the repository, which can be used with
 
223
            repository.get_inventory.
 
224
        """
 
225
        if self.new_inventory is None:
 
226
            # an inventory delta was accumulated without creating a new
 
227
            # inventory.
 
228
            basis_id = self.basis_delta_revision
 
229
            # We ignore the 'inventory' returned by add_inventory_by_delta
 
230
            # because self.new_inventory is used to hint to the rest of the
 
231
            # system what code path was taken
 
232
            self.inv_sha1, _ = self.repository.add_inventory_by_delta(
 
233
                basis_id, self._basis_delta, self._new_revision_id,
 
234
                self.parents)
 
235
        else:
 
236
            if self.new_inventory.root is None:
 
237
                raise AssertionError('Root entry should be supplied to'
 
238
                    ' record_entry_contents, as of bzr 0.10.')
 
239
                self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
 
240
            self.new_inventory.revision_id = self._new_revision_id
 
241
            self.inv_sha1 = self.repository.add_inventory(
 
242
                self._new_revision_id,
 
243
                self.new_inventory,
 
244
                self.parents
 
245
                )
 
246
        return self._new_revision_id
 
247
 
 
248
    def _gen_revision_id(self):
 
249
        """Return new revision-id."""
 
250
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
 
251
 
 
252
    def _generate_revision_if_needed(self):
 
253
        """Create a revision id if None was supplied.
 
254
 
 
255
        If the repository can not support user-specified revision ids
 
256
        they should override this function and raise CannotSetRevisionId
 
257
        if _new_revision_id is not None.
 
258
 
 
259
        :raises: CannotSetRevisionId
 
260
        """
 
261
        if self._new_revision_id is None:
 
262
            self._new_revision_id = self._gen_revision_id()
 
263
            self.random_revid = True
 
264
        else:
 
265
            self.random_revid = False
 
266
 
 
267
    def _heads(self, file_id, revision_ids):
 
268
        """Calculate the graph heads for revision_ids in the graph of file_id.
 
269
 
 
270
        This can use either a per-file graph or a global revision graph as we
 
271
        have an identity relationship between the two graphs.
 
272
        """
 
273
        return self.__heads(revision_ids)
 
274
 
 
275
    def _check_root(self, ie, parent_invs, tree):
 
276
        """Helper for record_entry_contents.
 
277
 
 
278
        :param ie: An entry being added.
 
279
        :param parent_invs: The inventories of the parent revisions of the
 
280
            commit.
 
281
        :param tree: The tree that is being committed.
 
282
        """
 
283
        # In this revision format, root entries have no knit or weave When
 
284
        # serializing out to disk and back in root.revision is always
 
285
        # _new_revision_id
 
286
        ie.revision = self._new_revision_id
 
287
 
 
288
    def _require_root_change(self, tree):
 
289
        """Enforce an appropriate root object change.
 
290
 
 
291
        This is called once when record_iter_changes is called, if and only if
 
292
        the root was not in the delta calculated by record_iter_changes.
 
293
 
 
294
        :param tree: The tree which is being committed.
 
295
        """
 
296
        if len(self.parents) == 0:
 
297
            raise errors.RootMissing()
 
298
        entry = entry_factory['directory'](tree.path2id(''), '',
 
299
            None)
 
300
        entry.revision = self._new_revision_id
 
301
        self._basis_delta.append(('', '', entry.file_id, entry))
 
302
 
 
303
    def _get_delta(self, ie, basis_inv, path):
 
304
        """Get a delta against the basis inventory for ie."""
 
305
        if ie.file_id not in basis_inv:
 
306
            # add
 
307
            result = (None, path, ie.file_id, ie)
 
308
            self._basis_delta.append(result)
 
309
            return result
 
310
        elif ie != basis_inv[ie.file_id]:
 
311
            # common but altered
 
312
            # TODO: avoid tis id2path call.
 
313
            result = (basis_inv.id2path(ie.file_id), path, ie.file_id, ie)
 
314
            self._basis_delta.append(result)
 
315
            return result
 
316
        else:
 
317
            # common, unaltered
 
318
            return None
 
319
 
 
320
    def get_basis_delta(self):
 
321
        """Return the complete inventory delta versus the basis inventory.
 
322
 
 
323
        This has been built up with the calls to record_delete and
 
324
        record_entry_contents. The client must have already called
 
325
        will_record_deletes() to indicate that they will be generating a
 
326
        complete delta.
 
327
 
 
328
        :return: An inventory delta, suitable for use with apply_delta, or
 
329
            Repository.add_inventory_by_delta, etc.
 
330
        """
 
331
        if not self._recording_deletes:
 
332
            raise AssertionError("recording deletes not activated.")
 
333
        return self._basis_delta
 
334
 
 
335
    def record_delete(self, path, file_id):
 
336
        """Record that a delete occured against a basis tree.
 
337
 
 
338
        This is an optional API - when used it adds items to the basis_delta
 
339
        being accumulated by the commit builder. It cannot be called unless the
 
340
        method will_record_deletes() has been called to inform the builder that
 
341
        a delta is being supplied.
 
342
 
 
343
        :param path: The path of the thing deleted.
 
344
        :param file_id: The file id that was deleted.
 
345
        """
 
346
        if not self._recording_deletes:
 
347
            raise AssertionError("recording deletes not activated.")
 
348
        delta = (path, None, file_id, None)
 
349
        self._basis_delta.append(delta)
 
350
        self._any_changes = True
 
351
        return delta
 
352
 
 
353
    def will_record_deletes(self):
 
354
        """Tell the commit builder that deletes are being notified.
 
355
 
 
356
        This enables the accumulation of an inventory delta; for the resulting
 
357
        commit to be valid, deletes against the basis MUST be recorded via
 
358
        builder.record_delete().
 
359
        """
 
360
        self._recording_deletes = True
 
361
        try:
 
362
            basis_id = self.parents[0]
 
363
        except IndexError:
 
364
            basis_id = _mod_revision.NULL_REVISION
 
365
        self.basis_delta_revision = basis_id
 
366
 
 
367
    def record_entry_contents(self, ie, parent_invs, path, tree,
 
368
        content_summary):
 
369
        """Record the content of ie from tree into the commit if needed.
 
370
 
 
371
        Side effect: sets ie.revision when unchanged
 
372
 
 
373
        :param ie: An inventory entry present in the commit.
 
374
        :param parent_invs: The inventories of the parent revisions of the
 
375
            commit.
 
376
        :param path: The path the entry is at in the tree.
 
377
        :param tree: The tree which contains this entry and should be used to
 
378
            obtain content.
 
379
        :param content_summary: Summary data from the tree about the paths
 
380
            content - stat, length, exec, sha/link target. This is only
 
381
            accessed when the entry has a revision of None - that is when it is
 
382
            a candidate to commit.
 
383
        :return: A tuple (change_delta, version_recorded, fs_hash).
 
384
            change_delta is an inventory_delta change for this entry against
 
385
            the basis tree of the commit, or None if no change occured against
 
386
            the basis tree.
 
387
            version_recorded is True if a new version of the entry has been
 
388
            recorded. For instance, committing a merge where a file was only
 
389
            changed on the other side will return (delta, False).
 
390
            fs_hash is either None, or the hash details for the path (currently
 
391
            a tuple of the contents sha1 and the statvalue returned by
 
392
            tree.get_file_with_stat()).
 
393
        """
 
394
        if self.new_inventory.root is None:
 
395
            if ie.parent_id is not None:
 
396
                raise errors.RootMissing()
 
397
            self._check_root(ie, parent_invs, tree)
 
398
        if ie.revision is None:
 
399
            kind = content_summary[0]
 
400
        else:
 
401
            # ie is carried over from a prior commit
 
402
            kind = ie.kind
 
403
        # XXX: repository specific check for nested tree support goes here - if
 
404
        # the repo doesn't want nested trees we skip it ?
 
405
        if (kind == 'tree-reference' and
 
406
            not self.repository._format.supports_tree_reference):
 
407
            # mismatch between commit builder logic and repository:
 
408
            # this needs the entry creation pushed down into the builder.
 
409
            raise NotImplementedError('Missing repository subtree support.')
 
410
        self.new_inventory.add(ie)
 
411
 
 
412
        # TODO: slow, take it out of the inner loop.
 
413
        try:
 
414
            basis_inv = parent_invs[0]
 
415
        except IndexError:
 
416
            basis_inv = Inventory(root_id=None)
 
417
 
 
418
        # ie.revision is always None if the InventoryEntry is considered
 
419
        # for committing. We may record the previous parents revision if the
 
420
        # content is actually unchanged against a sole head.
 
421
        if ie.revision is not None:
 
422
            if not self._versioned_root and path == '':
 
423
                # repositories that do not version the root set the root's
 
424
                # revision to the new commit even when no change occurs (more
 
425
                # specifically, they do not record a revision on the root; and
 
426
                # the rev id is assigned to the root during deserialisation -
 
427
                # this masks when a change may have occurred against the basis.
 
428
                # To match this we always issue a delta, because the revision
 
429
                # of the root will always be changing.
 
430
                if ie.file_id in basis_inv:
 
431
                    delta = (basis_inv.id2path(ie.file_id), path,
 
432
                        ie.file_id, ie)
 
433
                else:
 
434
                    # add
 
435
                    delta = (None, path, ie.file_id, ie)
 
436
                self._basis_delta.append(delta)
 
437
                return delta, False, None
 
438
            else:
 
439
                # we don't need to commit this, because the caller already
 
440
                # determined that an existing revision of this file is
 
441
                # appropriate. If it's not being considered for committing then
 
442
                # it and all its parents to the root must be unaltered so
 
443
                # no-change against the basis.
 
444
                if ie.revision == self._new_revision_id:
 
445
                    raise AssertionError("Impossible situation, a skipped "
 
446
                        "inventory entry (%r) claims to be modified in this "
 
447
                        "commit (%r).", (ie, self._new_revision_id))
 
448
                return None, False, None
 
449
        # XXX: Friction: parent_candidates should return a list not a dict
 
450
        #      so that we don't have to walk the inventories again.
 
451
        parent_candiate_entries = ie.parent_candidates(parent_invs)
 
452
        head_set = self._heads(ie.file_id, parent_candiate_entries.keys())
 
453
        heads = []
 
454
        for inv in parent_invs:
 
455
            if ie.file_id in inv:
 
456
                old_rev = inv[ie.file_id].revision
 
457
                if old_rev in head_set:
 
458
                    heads.append(inv[ie.file_id].revision)
 
459
                    head_set.remove(inv[ie.file_id].revision)
 
460
 
 
461
        store = False
 
462
        # now we check to see if we need to write a new record to the
 
463
        # file-graph.
 
464
        # We write a new entry unless there is one head to the ancestors, and
 
465
        # the kind-derived content is unchanged.
 
466
 
 
467
        # Cheapest check first: no ancestors, or more the one head in the
 
468
        # ancestors, we write a new node.
 
469
        if len(heads) != 1:
 
470
            store = True
 
471
        if not store:
 
472
            # There is a single head, look it up for comparison
 
473
            parent_entry = parent_candiate_entries[heads[0]]
 
474
            # if the non-content specific data has changed, we'll be writing a
 
475
            # node:
 
476
            if (parent_entry.parent_id != ie.parent_id or
 
477
                parent_entry.name != ie.name):
 
478
                store = True
 
479
        # now we need to do content specific checks:
 
480
        if not store:
 
481
            # if the kind changed the content obviously has
 
482
            if kind != parent_entry.kind:
 
483
                store = True
 
484
        # Stat cache fingerprint feedback for the caller - None as we usually
 
485
        # don't generate one.
 
486
        fingerprint = None
 
487
        if kind == 'file':
 
488
            if content_summary[2] is None:
 
489
                raise ValueError("Files must not have executable = None")
 
490
            if not store:
 
491
                # We can't trust a check of the file length because of content
 
492
                # filtering...
 
493
                if (# if the exec bit has changed we have to store:
 
494
                    parent_entry.executable != content_summary[2]):
 
495
                    store = True
 
496
                elif parent_entry.text_sha1 == content_summary[3]:
 
497
                    # all meta and content is unchanged (using a hash cache
 
498
                    # hit to check the sha)
 
499
                    ie.revision = parent_entry.revision
 
500
                    ie.text_size = parent_entry.text_size
 
501
                    ie.text_sha1 = parent_entry.text_sha1
 
502
                    ie.executable = parent_entry.executable
 
503
                    return self._get_delta(ie, basis_inv, path), False, None
 
504
                else:
 
505
                    # Either there is only a hash change(no hash cache entry,
 
506
                    # or same size content change), or there is no change on
 
507
                    # this file at all.
 
508
                    # Provide the parent's hash to the store layer, so that the
 
509
                    # content is unchanged we will not store a new node.
 
510
                    nostore_sha = parent_entry.text_sha1
 
511
            if store:
 
512
                # We want to record a new node regardless of the presence or
 
513
                # absence of a content change in the file.
 
514
                nostore_sha = None
 
515
            ie.executable = content_summary[2]
 
516
            file_obj, stat_value = tree.get_file_with_stat(ie.file_id, path)
 
517
            try:
 
518
                text = file_obj.read()
 
519
            finally:
 
520
                file_obj.close()
 
521
            try:
 
522
                ie.text_sha1, ie.text_size = self._add_text_to_weave(
 
523
                    ie.file_id, text, heads, nostore_sha)
 
524
                # Let the caller know we generated a stat fingerprint.
 
525
                fingerprint = (ie.text_sha1, stat_value)
 
526
            except errors.ExistingContent:
 
527
                # Turns out that the file content was unchanged, and we were
 
528
                # only going to store a new node if it was changed. Carry over
 
529
                # the entry.
 
530
                ie.revision = parent_entry.revision
 
531
                ie.text_size = parent_entry.text_size
 
532
                ie.text_sha1 = parent_entry.text_sha1
 
533
                ie.executable = parent_entry.executable
 
534
                return self._get_delta(ie, basis_inv, path), False, None
 
535
        elif kind == 'directory':
 
536
            if not store:
 
537
                # all data is meta here, nothing specific to directory, so
 
538
                # carry over:
 
539
                ie.revision = parent_entry.revision
 
540
                return self._get_delta(ie, basis_inv, path), False, None
 
541
            self._add_text_to_weave(ie.file_id, '', heads, None)
 
542
        elif kind == 'symlink':
 
543
            current_link_target = content_summary[3]
 
544
            if not store:
 
545
                # symlink target is not generic metadata, check if it has
 
546
                # changed.
 
547
                if current_link_target != parent_entry.symlink_target:
 
548
                    store = True
 
549
            if not store:
 
550
                # unchanged, carry over.
 
551
                ie.revision = parent_entry.revision
 
552
                ie.symlink_target = parent_entry.symlink_target
 
553
                return self._get_delta(ie, basis_inv, path), False, None
 
554
            ie.symlink_target = current_link_target
 
555
            self._add_text_to_weave(ie.file_id, '', heads, None)
 
556
        elif kind == 'tree-reference':
 
557
            if not store:
 
558
                if content_summary[3] != parent_entry.reference_revision:
 
559
                    store = True
 
560
            if not store:
 
561
                # unchanged, carry over.
 
562
                ie.reference_revision = parent_entry.reference_revision
 
563
                ie.revision = parent_entry.revision
 
564
                return self._get_delta(ie, basis_inv, path), False, None
 
565
            ie.reference_revision = content_summary[3]
 
566
            if ie.reference_revision is None:
 
567
                raise AssertionError("invalid content_summary for nested tree: %r"
 
568
                    % (content_summary,))
 
569
            self._add_text_to_weave(ie.file_id, '', heads, None)
 
570
        else:
 
571
            raise NotImplementedError('unknown kind')
 
572
        ie.revision = self._new_revision_id
 
573
        self._any_changes = True
 
574
        return self._get_delta(ie, basis_inv, path), True, fingerprint
 
575
 
 
576
    def record_iter_changes(self, tree, basis_revision_id, iter_changes,
 
577
        _entry_factory=entry_factory):
 
578
        """Record a new tree via iter_changes.
 
579
 
 
580
        :param tree: The tree to obtain text contents from for changed objects.
 
581
        :param basis_revision_id: The revision id of the tree the iter_changes
 
582
            has been generated against. Currently assumed to be the same
 
583
            as self.parents[0] - if it is not, errors may occur.
 
584
        :param iter_changes: An iter_changes iterator with the changes to apply
 
585
            to basis_revision_id. The iterator must not include any items with
 
586
            a current kind of None - missing items must be either filtered out
 
587
            or errored-on beefore record_iter_changes sees the item.
 
588
        :param _entry_factory: Private method to bind entry_factory locally for
 
589
            performance.
 
590
        :return: A generator of (file_id, relpath, fs_hash) tuples for use with
 
591
            tree._observed_sha1.
 
592
        """
 
593
        # Create an inventory delta based on deltas between all the parents and
 
594
        # deltas between all the parent inventories. We use inventory delta's 
 
595
        # between the inventory objects because iter_changes masks
 
596
        # last-changed-field only changes.
 
597
        # Working data:
 
598
        # file_id -> change map, change is fileid, paths, changed, versioneds,
 
599
        # parents, names, kinds, executables
 
600
        merged_ids = {}
 
601
        # {file_id -> revision_id -> inventory entry, for entries in parent
 
602
        # trees that are not parents[0]
 
603
        parent_entries = {}
 
604
        ghost_basis = False
 
605
        try:
 
606
            revtrees = list(self.repository.revision_trees(self.parents))
 
607
        except errors.NoSuchRevision:
 
608
            # one or more ghosts, slow path.
 
609
            revtrees = []
 
610
            for revision_id in self.parents:
 
611
                try:
 
612
                    revtrees.append(self.repository.revision_tree(revision_id))
 
613
                except errors.NoSuchRevision:
 
614
                    if not revtrees:
 
615
                        basis_revision_id = _mod_revision.NULL_REVISION
 
616
                        ghost_basis = True
 
617
                    revtrees.append(self.repository.revision_tree(
 
618
                        _mod_revision.NULL_REVISION))
 
619
        # The basis inventory from a repository 
 
620
        if revtrees:
 
621
            basis_inv = revtrees[0].inventory
 
622
        else:
 
623
            basis_inv = self.repository.revision_tree(
 
624
                _mod_revision.NULL_REVISION).inventory
 
625
        if len(self.parents) > 0:
 
626
            if basis_revision_id != self.parents[0] and not ghost_basis:
 
627
                raise Exception(
 
628
                    "arbitrary basis parents not yet supported with merges")
 
629
            for revtree in revtrees[1:]:
 
630
                for change in revtree.inventory._make_delta(basis_inv):
 
631
                    if change[1] is None:
 
632
                        # Not present in this parent.
 
633
                        continue
 
634
                    if change[2] not in merged_ids:
 
635
                        if change[0] is not None:
 
636
                            basis_entry = basis_inv[change[2]]
 
637
                            merged_ids[change[2]] = [
 
638
                                # basis revid
 
639
                                basis_entry.revision,
 
640
                                # new tree revid
 
641
                                change[3].revision]
 
642
                            parent_entries[change[2]] = {
 
643
                                # basis parent
 
644
                                basis_entry.revision:basis_entry,
 
645
                                # this parent 
 
646
                                change[3].revision:change[3],
 
647
                                }
 
648
                        else:
 
649
                            merged_ids[change[2]] = [change[3].revision]
 
650
                            parent_entries[change[2]] = {change[3].revision:change[3]}
 
651
                    else:
 
652
                        merged_ids[change[2]].append(change[3].revision)
 
653
                        parent_entries[change[2]][change[3].revision] = change[3]
 
654
        else:
 
655
            merged_ids = {}
 
656
        # Setup the changes from the tree:
 
657
        # changes maps file_id -> (change, [parent revision_ids])
 
658
        changes= {}
 
659
        for change in iter_changes:
 
660
            # This probably looks up in basis_inv way to much.
 
661
            if change[1][0] is not None:
 
662
                head_candidate = [basis_inv[change[0]].revision]
 
663
            else:
 
664
                head_candidate = []
 
665
            changes[change[0]] = change, merged_ids.get(change[0],
 
666
                head_candidate)
 
667
        unchanged_merged = set(merged_ids) - set(changes)
 
668
        # Extend the changes dict with synthetic changes to record merges of
 
669
        # texts.
 
670
        for file_id in unchanged_merged:
 
671
            # Record a merged version of these items that did not change vs the
 
672
            # basis. This can be either identical parallel changes, or a revert
 
673
            # of a specific file after a merge. The recorded content will be
 
674
            # that of the current tree (which is the same as the basis), but
 
675
            # the per-file graph will reflect a merge.
 
676
            # NB:XXX: We are reconstructing path information we had, this
 
677
            # should be preserved instead.
 
678
            # inv delta  change: (file_id, (path_in_source, path_in_target),
 
679
            #   changed_content, versioned, parent, name, kind,
 
680
            #   executable)
 
681
            try:
 
682
                basis_entry = basis_inv[file_id]
 
683
            except errors.NoSuchId:
 
684
                # a change from basis->some_parents but file_id isn't in basis
 
685
                # so was new in the merge, which means it must have changed
 
686
                # from basis -> current, and as it hasn't the add was reverted
 
687
                # by the user. So we discard this change.
 
688
                pass
 
689
            else:
 
690
                change = (file_id,
 
691
                    (basis_inv.id2path(file_id), tree.id2path(file_id)),
 
692
                    False, (True, True),
 
693
                    (basis_entry.parent_id, basis_entry.parent_id),
 
694
                    (basis_entry.name, basis_entry.name),
 
695
                    (basis_entry.kind, basis_entry.kind),
 
696
                    (basis_entry.executable, basis_entry.executable))
 
697
                changes[file_id] = (change, merged_ids[file_id])
 
698
        # changes contains tuples with the change and a set of inventory
 
699
        # candidates for the file.
 
700
        # inv delta is:
 
701
        # old_path, new_path, file_id, new_inventory_entry
 
702
        seen_root = False # Is the root in the basis delta?
 
703
        inv_delta = self._basis_delta
 
704
        modified_rev = self._new_revision_id
 
705
        for change, head_candidates in changes.values():
 
706
            if change[3][1]: # versioned in target.
 
707
                # Several things may be happening here:
 
708
                # We may have a fork in the per-file graph
 
709
                #  - record a change with the content from tree
 
710
                # We may have a change against < all trees  
 
711
                #  - carry over the tree that hasn't changed
 
712
                # We may have a change against all trees
 
713
                #  - record the change with the content from tree
 
714
                kind = change[6][1]
 
715
                file_id = change[0]
 
716
                entry = _entry_factory[kind](file_id, change[5][1],
 
717
                    change[4][1])
 
718
                head_set = self._heads(change[0], set(head_candidates))
 
719
                heads = []
 
720
                # Preserve ordering.
 
721
                for head_candidate in head_candidates:
 
722
                    if head_candidate in head_set:
 
723
                        heads.append(head_candidate)
 
724
                        head_set.remove(head_candidate)
 
725
                carried_over = False
 
726
                if len(heads) == 1:
 
727
                    # Could be a carry-over situation:
 
728
                    parent_entry_revs = parent_entries.get(file_id, None)
 
729
                    if parent_entry_revs:
 
730
                        parent_entry = parent_entry_revs.get(heads[0], None)
 
731
                    else:
 
732
                        parent_entry = None
 
733
                    if parent_entry is None:
 
734
                        # The parent iter_changes was called against is the one
 
735
                        # that is the per-file head, so any change is relevant
 
736
                        # iter_changes is valid.
 
737
                        carry_over_possible = False
 
738
                    else:
 
739
                        # could be a carry over situation
 
740
                        # A change against the basis may just indicate a merge,
 
741
                        # we need to check the content against the source of the
 
742
                        # merge to determine if it was changed after the merge
 
743
                        # or carried over.
 
744
                        if (parent_entry.kind != entry.kind or
 
745
                            parent_entry.parent_id != entry.parent_id or
 
746
                            parent_entry.name != entry.name):
 
747
                            # Metadata common to all entries has changed
 
748
                            # against per-file parent
 
749
                            carry_over_possible = False
 
750
                        else:
 
751
                            carry_over_possible = True
 
752
                        # per-type checks for changes against the parent_entry
 
753
                        # are done below.
 
754
                else:
 
755
                    # Cannot be a carry-over situation
 
756
                    carry_over_possible = False
 
757
                # Populate the entry in the delta
 
758
                if kind == 'file':
 
759
                    # XXX: There is still a small race here: If someone reverts the content of a file
 
760
                    # after iter_changes examines and decides it has changed,
 
761
                    # we will unconditionally record a new version even if some
 
762
                    # other process reverts it while commit is running (with
 
763
                    # the revert happening after iter_changes did its
 
764
                    # examination).
 
765
                    if change[7][1]:
 
766
                        entry.executable = True
 
767
                    else:
 
768
                        entry.executable = False
 
769
                    if (carry_over_possible and
 
770
                        parent_entry.executable == entry.executable):
 
771
                            # Check the file length, content hash after reading
 
772
                            # the file.
 
773
                            nostore_sha = parent_entry.text_sha1
 
774
                    else:
 
775
                        nostore_sha = None
 
776
                    file_obj, stat_value = tree.get_file_with_stat(file_id, change[1][1])
 
777
                    try:
 
778
                        text = file_obj.read()
 
779
                    finally:
 
780
                        file_obj.close()
 
781
                    try:
 
782
                        entry.text_sha1, entry.text_size = self._add_text_to_weave(
 
783
                            file_id, text, heads, nostore_sha)
 
784
                        yield file_id, change[1][1], (entry.text_sha1, stat_value)
 
785
                    except errors.ExistingContent:
 
786
                        # No content change against a carry_over parent
 
787
                        # Perhaps this should also yield a fs hash update?
 
788
                        carried_over = True
 
789
                        entry.text_size = parent_entry.text_size
 
790
                        entry.text_sha1 = parent_entry.text_sha1
 
791
                elif kind == 'symlink':
 
792
                    # Wants a path hint?
 
793
                    entry.symlink_target = tree.get_symlink_target(file_id)
 
794
                    if (carry_over_possible and
 
795
                        parent_entry.symlink_target == entry.symlink_target):
 
796
                        carried_over = True
 
797
                    else:
 
798
                        self._add_text_to_weave(change[0], '', heads, None)
 
799
                elif kind == 'directory':
 
800
                    if carry_over_possible:
 
801
                        carried_over = True
 
802
                    else:
 
803
                        # Nothing to set on the entry.
 
804
                        # XXX: split into the Root and nonRoot versions.
 
805
                        if change[1][1] != '' or self.repository.supports_rich_root():
 
806
                            self._add_text_to_weave(change[0], '', heads, None)
 
807
                elif kind == 'tree-reference':
 
808
                    if not self.repository._format.supports_tree_reference:
 
809
                        # This isn't quite sane as an error, but we shouldn't
 
810
                        # ever see this code path in practice: tree's don't
 
811
                        # permit references when the repo doesn't support tree
 
812
                        # references.
 
813
                        raise errors.UnsupportedOperation(tree.add_reference,
 
814
                            self.repository)
 
815
                    reference_revision = tree.get_reference_revision(change[0])
 
816
                    entry.reference_revision = reference_revision
 
817
                    if (carry_over_possible and
 
818
                        parent_entry.reference_revision == reference_revision):
 
819
                        carried_over = True
 
820
                    else:
 
821
                        self._add_text_to_weave(change[0], '', heads, None)
 
822
                else:
 
823
                    raise AssertionError('unknown kind %r' % kind)
 
824
                if not carried_over:
 
825
                    entry.revision = modified_rev
 
826
                else:
 
827
                    entry.revision = parent_entry.revision
 
828
            else:
 
829
                entry = None
 
830
            new_path = change[1][1]
 
831
            inv_delta.append((change[1][0], new_path, change[0], entry))
 
832
            if new_path == '':
 
833
                seen_root = True
 
834
        self.new_inventory = None
 
835
        if len(inv_delta):
 
836
            # This should perhaps be guarded by a check that the basis we
 
837
            # commit against is the basis for the commit and if not do a delta
 
838
            # against the basis.
 
839
            self._any_changes = True
 
840
        if not seen_root:
 
841
            # housekeeping root entry changes do not affect no-change commits.
 
842
            self._require_root_change(tree)
 
843
        self.basis_delta_revision = basis_revision_id
 
844
 
 
845
    def _add_text_to_weave(self, file_id, new_text, parents, nostore_sha):
 
846
        parent_keys = tuple([(file_id, parent) for parent in parents])
 
847
        return self.repository.texts._add_text(
 
848
            (file_id, self._new_revision_id), parent_keys, new_text,
 
849
            nostore_sha=nostore_sha, random_id=self.random_revid)[0:2]
 
850
 
 
851
 
 
852
class RootCommitBuilder(CommitBuilder):
 
853
    """This commitbuilder actually records the root id"""
 
854
 
 
855
    # the root entry gets versioned properly by this builder.
 
856
    _versioned_root = True
 
857
 
 
858
    def _check_root(self, ie, parent_invs, tree):
 
859
        """Helper for record_entry_contents.
 
860
 
 
861
        :param ie: An entry being added.
 
862
        :param parent_invs: The inventories of the parent revisions of the
 
863
            commit.
 
864
        :param tree: The tree that is being committed.
 
865
        """
 
866
 
 
867
    def _require_root_change(self, tree):
 
868
        """Enforce an appropriate root object change.
 
869
 
 
870
        This is called once when record_iter_changes is called, if and only if
 
871
        the root was not in the delta calculated by record_iter_changes.
 
872
 
 
873
        :param tree: The tree which is being committed.
 
874
        """
 
875
        # versioned roots do not change unless the tree found a change.
 
876
 
 
877
 
 
878
class RepositoryWriteLockResult(LogicalLockResult):
 
879
    """The result of write locking a repository.
 
880
 
 
881
    :ivar repository_token: The token obtained from the underlying lock, or
 
882
        None.
 
883
    :ivar unlock: A callable which will unlock the lock.
 
884
    """
 
885
 
 
886
    def __init__(self, unlock, repository_token):
 
887
        LogicalLockResult.__init__(self, unlock)
 
888
        self.repository_token = repository_token
 
889
 
 
890
    def __repr__(self):
 
891
        return "RepositoryWriteLockResult(%s, %s)" % (self.repository_token,
 
892
            self.unlock)
 
893
 
 
894
 
 
895
######################################################################
 
896
# Repositories
 
897
 
 
898
 
 
899
class Repository(_RelockDebugMixin, controldir.ControlComponent):
50
900
    """Repository holding history for one or more branches.
51
901
 
52
902
    The repository holds and retrieves historical information including
53
903
    revisions and file history.  It's normally accessed only by the Branch,
54
904
    which views a particular line of development through that history.
55
905
 
56
 
    The Repository builds on top of Stores and a Transport, which respectively 
57
 
    describe the disk data format and the way of accessing the (possibly 
 
906
    The Repository builds on top of some byte storage facilies (the revisions,
 
907
    signatures, inventories, texts and chk_bytes attributes) and a Transport,
 
908
    which respectively provide byte storage and a means to access the (possibly
58
909
    remote) disk.
 
910
 
 
911
    The byte storage facilities are addressed via tuples, which we refer to
 
912
    as 'keys' throughout the code base. Revision_keys, inventory_keys and
 
913
    signature_keys are all 1-tuples: (revision_id,). text_keys are two-tuples:
 
914
    (file_id, revision_id). chk_bytes uses CHK keys - a 1-tuple with a single
 
915
    byte string made up of a hash identifier and a hash value.
 
916
    We use this interface because it allows low friction with the underlying
 
917
    code that implements disk indices, network encoding and other parts of
 
918
    bzrlib.
 
919
 
 
920
    :ivar revisions: A bzrlib.versionedfile.VersionedFiles instance containing
 
921
        the serialised revisions for the repository. This can be used to obtain
 
922
        revision graph information or to access raw serialised revisions.
 
923
        The result of trying to insert data into the repository via this store
 
924
        is undefined: it should be considered read-only except for implementors
 
925
        of repositories.
 
926
    :ivar signatures: A bzrlib.versionedfile.VersionedFiles instance containing
 
927
        the serialised signatures for the repository. This can be used to
 
928
        obtain access to raw serialised signatures.  The result of trying to
 
929
        insert data into the repository via this store is undefined: it should
 
930
        be considered read-only except for implementors of repositories.
 
931
    :ivar inventories: A bzrlib.versionedfile.VersionedFiles instance containing
 
932
        the serialised inventories for the repository. This can be used to
 
933
        obtain unserialised inventories.  The result of trying to insert data
 
934
        into the repository via this store is undefined: it should be
 
935
        considered read-only except for implementors of repositories.
 
936
    :ivar texts: A bzrlib.versionedfile.VersionedFiles instance containing the
 
937
        texts of files and directories for the repository. This can be used to
 
938
        obtain file texts or file graphs. Note that Repository.iter_file_bytes
 
939
        is usually a better interface for accessing file texts.
 
940
        The result of trying to insert data into the repository via this store
 
941
        is undefined: it should be considered read-only except for implementors
 
942
        of repositories.
 
943
    :ivar chk_bytes: A bzrlib.versionedfile.VersionedFiles instance containing
 
944
        any data the repository chooses to store or have indexed by its hash.
 
945
        The result of trying to insert data into the repository via this store
 
946
        is undefined: it should be considered read-only except for implementors
 
947
        of repositories.
 
948
    :ivar _transport: Transport for file access to repository, typically
 
949
        pointing to .bzr/repository.
59
950
    """
60
951
 
61
 
    @needs_write_lock
62
 
    def add_inventory(self, revid, inv, parents):
63
 
        """Add the inventory inv to the repository as revid.
64
 
        
65
 
        :param parents: The revision ids of the parents that revid
 
952
    # What class to use for a CommitBuilder. Often it's simpler to change this
 
953
    # in a Repository class subclass rather than to override
 
954
    # get_commit_builder.
 
955
    _commit_builder_class = CommitBuilder
 
956
    # The search regex used by xml based repositories to determine what things
 
957
    # where changed in a single commit.
 
958
    _file_ids_altered_regex = lazy_regex.lazy_compile(
 
959
        r'file_id="(?P<file_id>[^"]+)"'
 
960
        r'.* revision="(?P<revision_id>[^"]+)"'
 
961
        )
 
962
 
 
963
    def abort_write_group(self, suppress_errors=False):
 
964
        """Commit the contents accrued within the current write group.
 
965
 
 
966
        :param suppress_errors: if true, abort_write_group will catch and log
 
967
            unexpected errors that happen during the abort, rather than
 
968
            allowing them to propagate.  Defaults to False.
 
969
 
 
970
        :seealso: start_write_group.
 
971
        """
 
972
        if self._write_group is not self.get_transaction():
 
973
            # has an unlock or relock occured ?
 
974
            if suppress_errors:
 
975
                mutter(
 
976
                '(suppressed) mismatched lock context and write group. %r, %r',
 
977
                self._write_group, self.get_transaction())
 
978
                return
 
979
            raise errors.BzrError(
 
980
                'mismatched lock context and write group. %r, %r' %
 
981
                (self._write_group, self.get_transaction()))
 
982
        try:
 
983
            self._abort_write_group()
 
984
        except Exception, exc:
 
985
            self._write_group = None
 
986
            if not suppress_errors:
 
987
                raise
 
988
            mutter('abort_write_group failed')
 
989
            log_exception_quietly()
 
990
            note('bzr: ERROR (ignored): %s', exc)
 
991
        self._write_group = None
 
992
 
 
993
    def _abort_write_group(self):
 
994
        """Template method for per-repository write group cleanup.
 
995
 
 
996
        This is called during abort before the write group is considered to be
 
997
        finished and should cleanup any internal state accrued during the write
 
998
        group. There is no requirement that data handed to the repository be
 
999
        *not* made available - this is not a rollback - but neither should any
 
1000
        attempt be made to ensure that data added is fully commited. Abort is
 
1001
        invoked when an error has occured so futher disk or network operations
 
1002
        may not be possible or may error and if possible should not be
 
1003
        attempted.
 
1004
        """
 
1005
 
 
1006
    def add_fallback_repository(self, repository):
 
1007
        """Add a repository to use for looking up data not held locally.
 
1008
 
 
1009
        :param repository: A repository.
 
1010
        """
 
1011
        if not self._format.supports_external_lookups:
 
1012
            raise errors.UnstackableRepositoryFormat(self._format, self.base)
 
1013
        if self.is_locked():
 
1014
            # This repository will call fallback.unlock() when we transition to
 
1015
            # the unlocked state, so we make sure to increment the lock count
 
1016
            repository.lock_read()
 
1017
        self._check_fallback_repository(repository)
 
1018
        self._fallback_repositories.append(repository)
 
1019
        self.texts.add_fallback_versioned_files(repository.texts)
 
1020
        self.inventories.add_fallback_versioned_files(repository.inventories)
 
1021
        self.revisions.add_fallback_versioned_files(repository.revisions)
 
1022
        self.signatures.add_fallback_versioned_files(repository.signatures)
 
1023
        if self.chk_bytes is not None:
 
1024
            self.chk_bytes.add_fallback_versioned_files(repository.chk_bytes)
 
1025
 
 
1026
    def _check_fallback_repository(self, repository):
 
1027
        """Check that this repository can fallback to repository safely.
 
1028
 
 
1029
        Raise an error if not.
 
1030
 
 
1031
        :param repository: A repository to fallback to.
 
1032
        """
 
1033
        return InterRepository._assert_same_model(self, repository)
 
1034
 
 
1035
    def add_inventory(self, revision_id, inv, parents):
 
1036
        """Add the inventory inv to the repository as revision_id.
 
1037
 
 
1038
        :param parents: The revision ids of the parents that revision_id
66
1039
                        is known to have and are in the repository already.
67
1040
 
68
 
        returns the sha1 of the serialized inventory.
69
 
        """
70
 
        assert inv.revision_id is None or inv.revision_id == revid, \
71
 
            "Mismatch between inventory revision" \
72
 
            " id and insertion revid (%r, %r)" % (inv.revision_id, revid)
73
 
        inv_text = xml5.serializer_v5.write_inventory_to_string(inv)
74
 
        inv_sha1 = osutils.sha_string(inv_text)
75
 
        inv_vf = self.control_weaves.get_weave('inventory',
76
 
                                               self.get_transaction())
77
 
        self._inventory_add_lines(inv_vf, revid, parents, osutils.split_lines(inv_text))
78
 
        return inv_sha1
79
 
 
80
 
    def _inventory_add_lines(self, inv_vf, revid, parents, lines):
81
 
        final_parents = []
82
 
        for parent in parents:
83
 
            if parent in inv_vf:
84
 
                final_parents.append(parent)
85
 
 
86
 
        inv_vf.add_lines(revid, final_parents, lines)
87
 
 
88
 
    @needs_write_lock
89
 
    def add_revision(self, rev_id, rev, inv=None, config=None):
90
 
        """Add rev to the revision store as rev_id.
91
 
 
92
 
        :param rev_id: the revision id to use.
 
1041
        :returns: The validator(which is a sha1 digest, though what is sha'd is
 
1042
            repository format specific) of the serialized inventory.
 
1043
        """
 
1044
        if not self.is_in_write_group():
 
1045
            raise AssertionError("%r not in write group" % (self,))
 
1046
        _mod_revision.check_not_reserved_id(revision_id)
 
1047
        if not (inv.revision_id is None or inv.revision_id == revision_id):
 
1048
            raise AssertionError(
 
1049
                "Mismatch between inventory revision"
 
1050
                " id and insertion revid (%r, %r)"
 
1051
                % (inv.revision_id, revision_id))
 
1052
        if inv.root is None:
 
1053
            raise errors.RootMissing()
 
1054
        return self._add_inventory_checked(revision_id, inv, parents)
 
1055
 
 
1056
    def _add_inventory_checked(self, revision_id, inv, parents):
 
1057
        """Add inv to the repository after checking the inputs.
 
1058
 
 
1059
        This function can be overridden to allow different inventory styles.
 
1060
 
 
1061
        :seealso: add_inventory, for the contract.
 
1062
        """
 
1063
        inv_lines = self._serializer.write_inventory_to_lines(inv)
 
1064
        return self._inventory_add_lines(revision_id, parents,
 
1065
            inv_lines, check_content=False)
 
1066
 
 
1067
    def add_inventory_by_delta(self, basis_revision_id, delta, new_revision_id,
 
1068
                               parents, basis_inv=None, propagate_caches=False):
 
1069
        """Add a new inventory expressed as a delta against another revision.
 
1070
 
 
1071
        See the inventory developers documentation for the theory behind
 
1072
        inventory deltas.
 
1073
 
 
1074
        :param basis_revision_id: The inventory id the delta was created
 
1075
            against. (This does not have to be a direct parent.)
 
1076
        :param delta: The inventory delta (see Inventory.apply_delta for
 
1077
            details).
 
1078
        :param new_revision_id: The revision id that the inventory is being
 
1079
            added for.
 
1080
        :param parents: The revision ids of the parents that revision_id is
 
1081
            known to have and are in the repository already. These are supplied
 
1082
            for repositories that depend on the inventory graph for revision
 
1083
            graph access, as well as for those that pun ancestry with delta
 
1084
            compression.
 
1085
        :param basis_inv: The basis inventory if it is already known,
 
1086
            otherwise None.
 
1087
        :param propagate_caches: If True, the caches for this inventory are
 
1088
          copied to and updated for the result if possible.
 
1089
 
 
1090
        :returns: (validator, new_inv)
 
1091
            The validator(which is a sha1 digest, though what is sha'd is
 
1092
            repository format specific) of the serialized inventory, and the
 
1093
            resulting inventory.
 
1094
        """
 
1095
        if not self.is_in_write_group():
 
1096
            raise AssertionError("%r not in write group" % (self,))
 
1097
        _mod_revision.check_not_reserved_id(new_revision_id)
 
1098
        basis_tree = self.revision_tree(basis_revision_id)
 
1099
        basis_tree.lock_read()
 
1100
        try:
 
1101
            # Note that this mutates the inventory of basis_tree, which not all
 
1102
            # inventory implementations may support: A better idiom would be to
 
1103
            # return a new inventory, but as there is no revision tree cache in
 
1104
            # repository this is safe for now - RBC 20081013
 
1105
            if basis_inv is None:
 
1106
                basis_inv = basis_tree.inventory
 
1107
            basis_inv.apply_delta(delta)
 
1108
            basis_inv.revision_id = new_revision_id
 
1109
            return (self.add_inventory(new_revision_id, basis_inv, parents),
 
1110
                    basis_inv)
 
1111
        finally:
 
1112
            basis_tree.unlock()
 
1113
 
 
1114
    def _inventory_add_lines(self, revision_id, parents, lines,
 
1115
        check_content=True):
 
1116
        """Store lines in inv_vf and return the sha1 of the inventory."""
 
1117
        parents = [(parent,) for parent in parents]
 
1118
        result = self.inventories.add_lines((revision_id,), parents, lines,
 
1119
            check_content=check_content)[0]
 
1120
        self.inventories._access.flush()
 
1121
        return result
 
1122
 
 
1123
    def add_revision(self, revision_id, rev, inv=None, config=None):
 
1124
        """Add rev to the revision store as revision_id.
 
1125
 
 
1126
        :param revision_id: the revision id to use.
93
1127
        :param rev: The revision object.
94
1128
        :param inv: The inventory for the revision. if None, it will be looked
95
1129
                    up in the inventory storer
97
1131
                       If supplied its signature_needed method will be used
98
1132
                       to determine if a signature should be made.
99
1133
        """
 
1134
        # TODO: jam 20070210 Shouldn't we check rev.revision_id and
 
1135
        #       rev.parent_ids?
 
1136
        _mod_revision.check_not_reserved_id(revision_id)
100
1137
        if config is not None and config.signature_needed():
101
1138
            if inv is None:
102
 
                inv = self.get_inventory(rev_id)
 
1139
                inv = self.get_inventory(revision_id)
103
1140
            plaintext = Testament(rev, inv).as_short_text()
104
1141
            self.store_revision_signature(
105
 
                gpg.GPGStrategy(config), plaintext, rev_id)
106
 
        if not rev_id in self.get_inventory_weave():
 
1142
                gpg.GPGStrategy(config), plaintext, revision_id)
 
1143
        # check inventory present
 
1144
        if not self.inventories.get_parent_map([(revision_id,)]):
107
1145
            if inv is None:
108
 
                raise errors.WeaveRevisionNotPresent(rev_id,
109
 
                                                     self.get_inventory_weave())
 
1146
                raise errors.WeaveRevisionNotPresent(revision_id,
 
1147
                                                     self.inventories)
110
1148
            else:
111
1149
                # yes, this is not suitable for adding with ghosts.
112
 
                self.add_inventory(rev_id, inv, rev.parent_ids)
113
 
        self._revision_store.add_revision(rev, self.get_transaction())
 
1150
                rev.inventory_sha1 = self.add_inventory(revision_id, inv,
 
1151
                                                        rev.parent_ids)
 
1152
        else:
 
1153
            key = (revision_id,)
 
1154
            rev.inventory_sha1 = self.inventories.get_sha1s([key])[key]
 
1155
        self._add_revision(rev)
114
1156
 
115
 
    @needs_read_lock
116
 
    def _all_possible_ids(self):
117
 
        """Return all the possible revisions that we could find."""
118
 
        return self.get_inventory_weave().versions()
 
1157
    def _add_revision(self, revision):
 
1158
        text = self._serializer.write_revision_to_string(revision)
 
1159
        key = (revision.revision_id,)
 
1160
        parents = tuple((parent,) for parent in revision.parent_ids)
 
1161
        self.revisions.add_lines(key, parents, osutils.split_lines(text))
119
1162
 
120
1163
    def all_revision_ids(self):
121
 
        """Returns a list of all the revision ids in the repository. 
 
1164
        """Returns a list of all the revision ids in the repository.
122
1165
 
123
 
        This is deprecated because code should generally work on the graph
124
 
        reachable from a particular revision, and ignore any other revisions
125
 
        that might be present.  There is no direct replacement method.
 
1166
        This is conceptually deprecated because code should generally work on
 
1167
        the graph reachable from a particular revision, and ignore any other
 
1168
        revisions that might be present.  There is no direct replacement
 
1169
        method.
126
1170
        """
 
1171
        if 'evil' in debug.debug_flags:
 
1172
            mutter_callsite(2, "all_revision_ids is linear with history.")
127
1173
        return self._all_revision_ids()
128
1174
 
129
 
    @needs_read_lock
130
1175
    def _all_revision_ids(self):
131
 
        """Returns a list of all the revision ids in the repository. 
 
1176
        """Returns a list of all the revision ids in the repository.
132
1177
 
133
 
        These are in as much topological order as the underlying store can 
134
 
        present: for weaves ghosts may lead to a lack of correctness until
135
 
        the reweave updates the parents list.
 
1178
        These are in as much topological order as the underlying store can
 
1179
        present.
136
1180
        """
137
 
        if self._revision_store.text_store.listable():
138
 
            return self._revision_store.all_revision_ids(self.get_transaction())
139
 
        result = self._all_possible_ids()
140
 
        return self._eliminate_revisions_not_present(result)
 
1181
        raise NotImplementedError(self._all_revision_ids)
141
1182
 
142
1183
    def break_lock(self):
143
1184
        """Break a lock if one is present from another instance.
154
1195
        Returns a set of the present revisions.
155
1196
        """
156
1197
        result = []
157
 
        for id in revision_ids:
158
 
            if self.has_revision(id):
159
 
               result.append(id)
160
 
        return result
 
1198
        graph = self.get_graph()
 
1199
        parent_map = graph.get_parent_map(revision_ids)
 
1200
        # The old API returned a list, should this actually be a set?
 
1201
        return parent_map.keys()
 
1202
 
 
1203
    def _check_inventories(self, checker):
 
1204
        """Check the inventories found from the revision scan.
 
1205
        
 
1206
        This is responsible for verifying the sha1 of inventories and
 
1207
        creating a pending_keys set that covers data referenced by inventories.
 
1208
        """
 
1209
        bar = ui.ui_factory.nested_progress_bar()
 
1210
        try:
 
1211
            self._do_check_inventories(checker, bar)
 
1212
        finally:
 
1213
            bar.finished()
 
1214
 
 
1215
    def _do_check_inventories(self, checker, bar):
 
1216
        """Helper for _check_inventories."""
 
1217
        revno = 0
 
1218
        keys = {'chk_bytes':set(), 'inventories':set(), 'texts':set()}
 
1219
        kinds = ['chk_bytes', 'texts']
 
1220
        count = len(checker.pending_keys)
 
1221
        bar.update("inventories", 0, 2)
 
1222
        current_keys = checker.pending_keys
 
1223
        checker.pending_keys = {}
 
1224
        # Accumulate current checks.
 
1225
        for key in current_keys:
 
1226
            if key[0] != 'inventories' and key[0] not in kinds:
 
1227
                checker._report_items.append('unknown key type %r' % (key,))
 
1228
            keys[key[0]].add(key[1:])
 
1229
        if keys['inventories']:
 
1230
            # NB: output order *should* be roughly sorted - topo or
 
1231
            # inverse topo depending on repository - either way decent
 
1232
            # to just delta against. However, pre-CHK formats didn't
 
1233
            # try to optimise inventory layout on disk. As such the
 
1234
            # pre-CHK code path does not use inventory deltas.
 
1235
            last_object = None
 
1236
            for record in self.inventories.check(keys=keys['inventories']):
 
1237
                if record.storage_kind == 'absent':
 
1238
                    checker._report_items.append(
 
1239
                        'Missing inventory {%s}' % (record.key,))
 
1240
                else:
 
1241
                    last_object = self._check_record('inventories', record,
 
1242
                        checker, last_object,
 
1243
                        current_keys[('inventories',) + record.key])
 
1244
            del keys['inventories']
 
1245
        else:
 
1246
            return
 
1247
        bar.update("texts", 1)
 
1248
        while (checker.pending_keys or keys['chk_bytes']
 
1249
            or keys['texts']):
 
1250
            # Something to check.
 
1251
            current_keys = checker.pending_keys
 
1252
            checker.pending_keys = {}
 
1253
            # Accumulate current checks.
 
1254
            for key in current_keys:
 
1255
                if key[0] not in kinds:
 
1256
                    checker._report_items.append('unknown key type %r' % (key,))
 
1257
                keys[key[0]].add(key[1:])
 
1258
            # Check the outermost kind only - inventories || chk_bytes || texts
 
1259
            for kind in kinds:
 
1260
                if keys[kind]:
 
1261
                    last_object = None
 
1262
                    for record in getattr(self, kind).check(keys=keys[kind]):
 
1263
                        if record.storage_kind == 'absent':
 
1264
                            checker._report_items.append(
 
1265
                                'Missing %s {%s}' % (kind, record.key,))
 
1266
                        else:
 
1267
                            last_object = self._check_record(kind, record,
 
1268
                                checker, last_object, current_keys[(kind,) + record.key])
 
1269
                    keys[kind] = set()
 
1270
                    break
 
1271
 
 
1272
    def _check_record(self, kind, record, checker, last_object, item_data):
 
1273
        """Check a single text from this repository."""
 
1274
        if kind == 'inventories':
 
1275
            rev_id = record.key[0]
 
1276
            inv = self._deserialise_inventory(rev_id,
 
1277
                record.get_bytes_as('fulltext'))
 
1278
            if last_object is not None:
 
1279
                delta = inv._make_delta(last_object)
 
1280
                for old_path, path, file_id, ie in delta:
 
1281
                    if ie is None:
 
1282
                        continue
 
1283
                    ie.check(checker, rev_id, inv)
 
1284
            else:
 
1285
                for path, ie in inv.iter_entries():
 
1286
                    ie.check(checker, rev_id, inv)
 
1287
            if self._format.fast_deltas:
 
1288
                return inv
 
1289
        elif kind == 'chk_bytes':
 
1290
            # No code written to check chk_bytes for this repo format.
 
1291
            checker._report_items.append(
 
1292
                'unsupported key type chk_bytes for %s' % (record.key,))
 
1293
        elif kind == 'texts':
 
1294
            self._check_text(record, checker, item_data)
 
1295
        else:
 
1296
            checker._report_items.append(
 
1297
                'unknown key type %s for %s' % (kind, record.key))
 
1298
 
 
1299
    def _check_text(self, record, checker, item_data):
 
1300
        """Check a single text."""
 
1301
        # Check it is extractable.
 
1302
        # TODO: check length.
 
1303
        if record.storage_kind == 'chunked':
 
1304
            chunks = record.get_bytes_as(record.storage_kind)
 
1305
            sha1 = osutils.sha_strings(chunks)
 
1306
            length = sum(map(len, chunks))
 
1307
        else:
 
1308
            content = record.get_bytes_as('fulltext')
 
1309
            sha1 = osutils.sha_string(content)
 
1310
            length = len(content)
 
1311
        if item_data and sha1 != item_data[1]:
 
1312
            checker._report_items.append(
 
1313
                'sha1 mismatch: %s has sha1 %s expected %s referenced by %s' %
 
1314
                (record.key, sha1, item_data[1], item_data[2]))
161
1315
 
162
1316
    @staticmethod
163
1317
    def create(a_bzrdir):
164
1318
        """Construct the current default format repository in a_bzrdir."""
165
1319
        return RepositoryFormat.get_default_format().initialize(a_bzrdir)
166
1320
 
167
 
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
 
1321
    def __init__(self, _format, a_bzrdir, control_files):
168
1322
        """instantiate a Repository.
169
1323
 
170
1324
        :param _format: The format of the repository on disk.
171
1325
        :param a_bzrdir: The BzrDir of the repository.
172
 
 
173
 
        In the future we will have a single api for all stores for
174
 
        getting file texts, inventories and revisions, then
175
 
        this construct will accept instances of those things.
176
1326
        """
 
1327
        # In the future we will have a single api for all stores for
 
1328
        # getting file texts, inventories and revisions, then
 
1329
        # this construct will accept instances of those things.
177
1330
        super(Repository, self).__init__()
178
1331
        self._format = _format
179
1332
        # the following are part of the public API for Repository:
180
1333
        self.bzrdir = a_bzrdir
181
1334
        self.control_files = control_files
182
 
        self._revision_store = _revision_store
183
 
        self.text_store = text_store
184
 
        # backwards compatibility
185
 
        self.weave_store = text_store
186
 
        # not right yet - should be more semantically clear ? 
187
 
        # 
188
 
        self.control_store = control_store
189
 
        self.control_weaves = control_store
190
 
        # TODO: make sure to construct the right store classes, etc, depending
191
 
        # on whether escaping is required.
 
1335
        self._transport = control_files._transport
 
1336
        self.base = self._transport.base
 
1337
        # for tests
 
1338
        self._reconcile_does_inventory_gc = True
 
1339
        self._reconcile_fixes_text_parents = False
 
1340
        self._reconcile_backsup_inventory = True
 
1341
        self._write_group = None
 
1342
        # Additional places to query for data.
 
1343
        self._fallback_repositories = []
 
1344
        # An InventoryEntry cache, used during deserialization
 
1345
        self._inventory_entry_cache = fifo_cache.FIFOCache(10*1024)
 
1346
        # Is it safe to return inventory entries directly from the entry cache,
 
1347
        # rather copying them?
 
1348
        self._safe_to_return_from_cache = False
 
1349
 
 
1350
    @property
 
1351
    def user_transport(self):
 
1352
        return self.bzrdir.user_transport
 
1353
 
 
1354
    @property
 
1355
    def control_transport(self):
 
1356
        return self._transport
192
1357
 
193
1358
    def __repr__(self):
194
 
        return '%s(%r)' % (self.__class__.__name__, 
195
 
                           self.bzrdir.transport.base)
 
1359
        if self._fallback_repositories:
 
1360
            return '%s(%r, fallback_repositories=%r)' % (
 
1361
                self.__class__.__name__,
 
1362
                self.base,
 
1363
                self._fallback_repositories)
 
1364
        else:
 
1365
            return '%s(%r)' % (self.__class__.__name__,
 
1366
                               self.base)
 
1367
 
 
1368
    def _has_same_fallbacks(self, other_repo):
 
1369
        """Returns true if the repositories have the same fallbacks."""
 
1370
        my_fb = self._fallback_repositories
 
1371
        other_fb = other_repo._fallback_repositories
 
1372
        if len(my_fb) != len(other_fb):
 
1373
            return False
 
1374
        for f, g in zip(my_fb, other_fb):
 
1375
            if not f.has_same_location(g):
 
1376
                return False
 
1377
        return True
 
1378
 
 
1379
    def has_same_location(self, other):
 
1380
        """Returns a boolean indicating if this repository is at the same
 
1381
        location as another repository.
 
1382
 
 
1383
        This might return False even when two repository objects are accessing
 
1384
        the same physical repository via different URLs.
 
1385
        """
 
1386
        if self.__class__ is not other.__class__:
 
1387
            return False
 
1388
        return (self._transport.base == other._transport.base)
 
1389
 
 
1390
    def is_in_write_group(self):
 
1391
        """Return True if there is an open write group.
 
1392
 
 
1393
        :seealso: start_write_group.
 
1394
        """
 
1395
        return self._write_group is not None
196
1396
 
197
1397
    def is_locked(self):
198
1398
        return self.control_files.is_locked()
199
1399
 
200
 
    def lock_write(self):
201
 
        self.control_files.lock_write()
 
1400
    def is_write_locked(self):
 
1401
        """Return True if this object is write locked."""
 
1402
        return self.is_locked() and self.control_files._lock_mode == 'w'
 
1403
 
 
1404
    def lock_write(self, token=None):
 
1405
        """Lock this repository for writing.
 
1406
 
 
1407
        This causes caching within the repository obejct to start accumlating
 
1408
        data during reads, and allows a 'write_group' to be obtained. Write
 
1409
        groups must be used for actual data insertion.
 
1410
 
 
1411
        A token should be passed in if you know that you have locked the object
 
1412
        some other way, and need to synchronise this object's state with that
 
1413
        fact.
 
1414
 
 
1415
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
 
1416
 
 
1417
        :param token: if this is already locked, then lock_write will fail
 
1418
            unless the token matches the existing lock.
 
1419
        :returns: a token if this instance supports tokens, otherwise None.
 
1420
        :raises TokenLockingNotSupported: when a token is given but this
 
1421
            instance doesn't support using token locks.
 
1422
        :raises MismatchedToken: if the specified token doesn't match the token
 
1423
            of the existing lock.
 
1424
        :seealso: start_write_group.
 
1425
        :return: A RepositoryWriteLockResult.
 
1426
        """
 
1427
        locked = self.is_locked()
 
1428
        token = self.control_files.lock_write(token=token)
 
1429
        if not locked:
 
1430
            self._warn_if_deprecated()
 
1431
            self._note_lock('w')
 
1432
            for repo in self._fallback_repositories:
 
1433
                # Writes don't affect fallback repos
 
1434
                repo.lock_read()
 
1435
            self._refresh_data()
 
1436
        return RepositoryWriteLockResult(self.unlock, token)
202
1437
 
203
1438
    def lock_read(self):
 
1439
        """Lock the repository for read operations.
 
1440
 
 
1441
        :return: An object with an unlock method which will release the lock
 
1442
            obtained.
 
1443
        """
 
1444
        locked = self.is_locked()
204
1445
        self.control_files.lock_read()
 
1446
        if not locked:
 
1447
            self._warn_if_deprecated()
 
1448
            self._note_lock('r')
 
1449
            for repo in self._fallback_repositories:
 
1450
                repo.lock_read()
 
1451
            self._refresh_data()
 
1452
        return LogicalLockResult(self.unlock)
205
1453
 
206
1454
    def get_physical_lock_status(self):
207
1455
        return self.control_files.get_physical_lock_status()
208
1456
 
209
 
    @needs_read_lock
210
 
    def missing_revision_ids(self, other, revision_id=None):
 
1457
    def leave_lock_in_place(self):
 
1458
        """Tell this repository not to release the physical lock when this
 
1459
        object is unlocked.
 
1460
 
 
1461
        If lock_write doesn't return a token, then this method is not supported.
 
1462
        """
 
1463
        self.control_files.leave_in_place()
 
1464
 
 
1465
    def dont_leave_lock_in_place(self):
 
1466
        """Tell this repository to release the physical lock when this
 
1467
        object is unlocked, even if it didn't originally acquire it.
 
1468
 
 
1469
        If lock_write doesn't return a token, then this method is not supported.
 
1470
        """
 
1471
        self.control_files.dont_leave_in_place()
 
1472
 
 
1473
    @needs_read_lock
 
1474
    def gather_stats(self, revid=None, committers=None):
 
1475
        """Gather statistics from a revision id.
 
1476
 
 
1477
        :param revid: The revision id to gather statistics from, if None, then
 
1478
            no revision specific statistics are gathered.
 
1479
        :param committers: Optional parameter controlling whether to grab
 
1480
            a count of committers from the revision specific statistics.
 
1481
        :return: A dictionary of statistics. Currently this contains:
 
1482
            committers: The number of committers if requested.
 
1483
            firstrev: A tuple with timestamp, timezone for the penultimate left
 
1484
                most ancestor of revid, if revid is not the NULL_REVISION.
 
1485
            latestrev: A tuple with timestamp, timezone for revid, if revid is
 
1486
                not the NULL_REVISION.
 
1487
            revisions: The total revision count in the repository.
 
1488
            size: An estimate disk size of the repository in bytes.
 
1489
        """
 
1490
        result = {}
 
1491
        if revid and committers:
 
1492
            result['committers'] = 0
 
1493
        if revid and revid != _mod_revision.NULL_REVISION:
 
1494
            if committers:
 
1495
                all_committers = set()
 
1496
            revisions = self.get_ancestry(revid)
 
1497
            # pop the leading None
 
1498
            revisions.pop(0)
 
1499
            first_revision = None
 
1500
            if not committers:
 
1501
                # ignore the revisions in the middle - just grab first and last
 
1502
                revisions = revisions[0], revisions[-1]
 
1503
            for revision in self.get_revisions(revisions):
 
1504
                if not first_revision:
 
1505
                    first_revision = revision
 
1506
                if committers:
 
1507
                    all_committers.add(revision.committer)
 
1508
            last_revision = revision
 
1509
            if committers:
 
1510
                result['committers'] = len(all_committers)
 
1511
            result['firstrev'] = (first_revision.timestamp,
 
1512
                first_revision.timezone)
 
1513
            result['latestrev'] = (last_revision.timestamp,
 
1514
                last_revision.timezone)
 
1515
 
 
1516
        # now gather global repository information
 
1517
        # XXX: This is available for many repos regardless of listability.
 
1518
        if self.user_transport.listable():
 
1519
            # XXX: do we want to __define len__() ?
 
1520
            # Maybe the versionedfiles object should provide a different
 
1521
            # method to get the number of keys.
 
1522
            result['revisions'] = len(self.revisions.keys())
 
1523
            # result['size'] = t
 
1524
        return result
 
1525
 
 
1526
    def find_branches(self, using=False):
 
1527
        """Find branches underneath this repository.
 
1528
 
 
1529
        This will include branches inside other branches.
 
1530
 
 
1531
        :param using: If True, list only branches using this repository.
 
1532
        """
 
1533
        if using and not self.is_shared():
 
1534
            return self.bzrdir.list_branches()
 
1535
        class Evaluator(object):
 
1536
 
 
1537
            def __init__(self):
 
1538
                self.first_call = True
 
1539
 
 
1540
            def __call__(self, bzrdir):
 
1541
                # On the first call, the parameter is always the bzrdir
 
1542
                # containing the current repo.
 
1543
                if not self.first_call:
 
1544
                    try:
 
1545
                        repository = bzrdir.open_repository()
 
1546
                    except errors.NoRepositoryPresent:
 
1547
                        pass
 
1548
                    else:
 
1549
                        return False, ([], repository)
 
1550
                self.first_call = False
 
1551
                value = (bzrdir.list_branches(), None)
 
1552
                return True, value
 
1553
 
 
1554
        ret = []
 
1555
        for branches, repository in bzrdir.BzrDir.find_bzrdirs(
 
1556
                self.user_transport, evaluate=Evaluator()):
 
1557
            if branches is not None:
 
1558
                ret.extend(branches)
 
1559
            if not using and repository is not None:
 
1560
                ret.extend(repository.find_branches())
 
1561
        return ret
 
1562
 
 
1563
    @needs_read_lock
 
1564
    def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
211
1565
        """Return the revision ids that other has that this does not.
212
 
        
 
1566
 
213
1567
        These are returned in topological order.
214
1568
 
215
1569
        revision_id: only return revision ids included by revision_id.
216
1570
        """
217
 
        return InterRepository.get(other, self).missing_revision_ids(revision_id)
 
1571
        return InterRepository.get(other, self).search_missing_revision_ids(
 
1572
            revision_id, find_ghosts)
218
1573
 
219
1574
    @staticmethod
220
1575
    def open(base):
226
1581
        control = bzrdir.BzrDir.open(base)
227
1582
        return control.open_repository()
228
1583
 
229
 
    def copy_content_into(self, destination, revision_id=None, basis=None):
 
1584
    def copy_content_into(self, destination, revision_id=None):
230
1585
        """Make a complete copy of the content in self into destination.
 
1586
 
 
1587
        This is a destructive operation! Do not use it on existing
 
1588
        repositories.
 
1589
        """
 
1590
        return InterRepository.get(self, destination).copy_content(revision_id)
 
1591
 
 
1592
    def commit_write_group(self):
 
1593
        """Commit the contents accrued within the current write group.
 
1594
 
 
1595
        :seealso: start_write_group.
231
1596
        
232
 
        This is a destructive operation! Do not use it on existing 
233
 
        repositories.
234
 
        """
235
 
        return InterRepository.get(self, destination).copy_content(revision_id, basis)
236
 
 
237
 
    def fetch(self, source, revision_id=None, pb=None):
 
1597
        :return: it may return an opaque hint that can be passed to 'pack'.
 
1598
        """
 
1599
        if self._write_group is not self.get_transaction():
 
1600
            # has an unlock or relock occured ?
 
1601
            raise errors.BzrError('mismatched lock context %r and '
 
1602
                'write group %r.' %
 
1603
                (self.get_transaction(), self._write_group))
 
1604
        result = self._commit_write_group()
 
1605
        self._write_group = None
 
1606
        return result
 
1607
 
 
1608
    def _commit_write_group(self):
 
1609
        """Template method for per-repository write group cleanup.
 
1610
 
 
1611
        This is called before the write group is considered to be
 
1612
        finished and should ensure that all data handed to the repository
 
1613
        for writing during the write group is safely committed (to the
 
1614
        extent possible considering file system caching etc).
 
1615
        """
 
1616
 
 
1617
    def suspend_write_group(self):
 
1618
        raise errors.UnsuspendableWriteGroup(self)
 
1619
 
 
1620
    def get_missing_parent_inventories(self, check_for_missing_texts=True):
 
1621
        """Return the keys of missing inventory parents for revisions added in
 
1622
        this write group.
 
1623
 
 
1624
        A revision is not complete if the inventory delta for that revision
 
1625
        cannot be calculated.  Therefore if the parent inventories of a
 
1626
        revision are not present, the revision is incomplete, and e.g. cannot
 
1627
        be streamed by a smart server.  This method finds missing inventory
 
1628
        parents for revisions added in this write group.
 
1629
        """
 
1630
        if not self._format.supports_external_lookups:
 
1631
            # This is only an issue for stacked repositories
 
1632
            return set()
 
1633
        if not self.is_in_write_group():
 
1634
            raise AssertionError('not in a write group')
 
1635
 
 
1636
        # XXX: We assume that every added revision already has its
 
1637
        # corresponding inventory, so we only check for parent inventories that
 
1638
        # might be missing, rather than all inventories.
 
1639
        parents = set(self.revisions._index.get_missing_parents())
 
1640
        parents.discard(_mod_revision.NULL_REVISION)
 
1641
        unstacked_inventories = self.inventories._index
 
1642
        present_inventories = unstacked_inventories.get_parent_map(
 
1643
            key[-1:] for key in parents)
 
1644
        parents.difference_update(present_inventories)
 
1645
        if len(parents) == 0:
 
1646
            # No missing parent inventories.
 
1647
            return set()
 
1648
        if not check_for_missing_texts:
 
1649
            return set(('inventories', rev_id) for (rev_id,) in parents)
 
1650
        # Ok, now we have a list of missing inventories.  But these only matter
 
1651
        # if the inventories that reference them are missing some texts they
 
1652
        # appear to introduce.
 
1653
        # XXX: Texts referenced by all added inventories need to be present,
 
1654
        # but at the moment we're only checking for texts referenced by
 
1655
        # inventories at the graph's edge.
 
1656
        key_deps = self.revisions._index._key_dependencies
 
1657
        key_deps.satisfy_refs_for_keys(present_inventories)
 
1658
        referrers = frozenset(r[0] for r in key_deps.get_referrers())
 
1659
        file_ids = self.fileids_altered_by_revision_ids(referrers)
 
1660
        missing_texts = set()
 
1661
        for file_id, version_ids in file_ids.iteritems():
 
1662
            missing_texts.update(
 
1663
                (file_id, version_id) for version_id in version_ids)
 
1664
        present_texts = self.texts.get_parent_map(missing_texts)
 
1665
        missing_texts.difference_update(present_texts)
 
1666
        if not missing_texts:
 
1667
            # No texts are missing, so all revisions and their deltas are
 
1668
            # reconstructable.
 
1669
            return set()
 
1670
        # Alternatively the text versions could be returned as the missing
 
1671
        # keys, but this is likely to be less data.
 
1672
        missing_keys = set(('inventories', rev_id) for (rev_id,) in parents)
 
1673
        return missing_keys
 
1674
 
 
1675
    def refresh_data(self):
 
1676
        """Re-read any data needed to synchronise with disk.
 
1677
 
 
1678
        This method is intended to be called after another repository instance
 
1679
        (such as one used by a smart server) has inserted data into the
 
1680
        repository. On all repositories this will work outside of write groups.
 
1681
        Some repository formats (pack and newer for bzrlib native formats)
 
1682
        support refresh_data inside write groups. If called inside a write
 
1683
        group on a repository that does not support refreshing in a write group
 
1684
        IsInWriteGroupError will be raised.
 
1685
        """
 
1686
        self._refresh_data()
 
1687
 
 
1688
    def resume_write_group(self, tokens):
 
1689
        if not self.is_write_locked():
 
1690
            raise errors.NotWriteLocked(self)
 
1691
        if self._write_group:
 
1692
            raise errors.BzrError('already in a write group')
 
1693
        self._resume_write_group(tokens)
 
1694
        # so we can detect unlock/relock - the write group is now entered.
 
1695
        self._write_group = self.get_transaction()
 
1696
 
 
1697
    def _resume_write_group(self, tokens):
 
1698
        raise errors.UnsuspendableWriteGroup(self)
 
1699
 
 
1700
    def fetch(self, source, revision_id=None, pb=None, find_ghosts=False,
 
1701
            fetch_spec=None):
238
1702
        """Fetch the content required to construct revision_id from source.
239
1703
 
240
 
        If revision_id is None all content is copied.
 
1704
        If revision_id is None and fetch_spec is None, then all content is
 
1705
        copied.
 
1706
 
 
1707
        fetch() may not be used when the repository is in a write group -
 
1708
        either finish the current write group before using fetch, or use
 
1709
        fetch before starting the write group.
 
1710
 
 
1711
        :param find_ghosts: Find and copy revisions in the source that are
 
1712
            ghosts in the target (and not reachable directly by walking out to
 
1713
            the first-present revision in target from revision_id).
 
1714
        :param revision_id: If specified, all the content needed for this
 
1715
            revision ID will be copied to the target.  Fetch will determine for
 
1716
            itself which content needs to be copied.
 
1717
        :param fetch_spec: If specified, a SearchResult or
 
1718
            PendingAncestryResult that describes which revisions to copy.  This
 
1719
            allows copying multiple heads at once.  Mutually exclusive with
 
1720
            revision_id.
241
1721
        """
242
 
        return InterRepository.get(source, self).fetch(revision_id=revision_id,
243
 
                                                       pb=pb)
244
 
 
245
 
    def get_commit_builder(self, branch, parents, config, timestamp=None, 
246
 
                           timezone=None, committer=None, revprops=None, 
 
1722
        if fetch_spec is not None and revision_id is not None:
 
1723
            raise AssertionError(
 
1724
                "fetch_spec and revision_id are mutually exclusive.")
 
1725
        if self.is_in_write_group():
 
1726
            raise errors.InternalBzrError(
 
1727
                "May not fetch while in a write group.")
 
1728
        # fast path same-url fetch operations
 
1729
        # TODO: lift out to somewhere common with RemoteRepository
 
1730
        # <https://bugs.launchpad.net/bzr/+bug/401646>
 
1731
        if (self.has_same_location(source)
 
1732
            and fetch_spec is None
 
1733
            and self._has_same_fallbacks(source)):
 
1734
            # check that last_revision is in 'from' and then return a
 
1735
            # no-operation.
 
1736
            if (revision_id is not None and
 
1737
                not _mod_revision.is_null(revision_id)):
 
1738
                self.get_revision(revision_id)
 
1739
            return 0, []
 
1740
        # if there is no specific appropriate InterRepository, this will get
 
1741
        # the InterRepository base class, which raises an
 
1742
        # IncompatibleRepositories when asked to fetch.
 
1743
        inter = InterRepository.get(source, self)
 
1744
        return inter.fetch(revision_id=revision_id, pb=pb,
 
1745
            find_ghosts=find_ghosts, fetch_spec=fetch_spec)
 
1746
 
 
1747
    def create_bundle(self, target, base, fileobj, format=None):
 
1748
        return serializer.write_bundle(self, target, base, fileobj, format)
 
1749
 
 
1750
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
1751
                           timezone=None, committer=None, revprops=None,
247
1752
                           revision_id=None):
248
1753
        """Obtain a CommitBuilder for this repository.
249
 
        
 
1754
 
250
1755
        :param branch: Branch to commit to.
251
1756
        :param parents: Revision ids of the parents of the new revision.
252
1757
        :param config: Configuration to use.
256
1761
        :param revprops: Optional dictionary of revision properties.
257
1762
        :param revision_id: Optional revision id.
258
1763
        """
259
 
        return CommitBuilder(self, parents, config, timestamp, timezone,
260
 
                             committer, revprops, revision_id)
 
1764
        if self._fallback_repositories:
 
1765
            raise errors.BzrError("Cannot commit from a lightweight checkout "
 
1766
                "to a stacked branch. See "
 
1767
                "https://bugs.launchpad.net/bzr/+bug/375013 for details.")
 
1768
        result = self._commit_builder_class(self, parents, config,
 
1769
            timestamp, timezone, committer, revprops, revision_id)
 
1770
        self.start_write_group()
 
1771
        return result
261
1772
 
 
1773
    @only_raises(errors.LockNotHeld, errors.LockBroken)
262
1774
    def unlock(self):
 
1775
        if (self.control_files._lock_count == 1 and
 
1776
            self.control_files._lock_mode == 'w'):
 
1777
            if self._write_group is not None:
 
1778
                self.abort_write_group()
 
1779
                self.control_files.unlock()
 
1780
                raise errors.BzrError(
 
1781
                    'Must end write groups before releasing write locks.')
263
1782
        self.control_files.unlock()
 
1783
        if self.control_files._lock_count == 0:
 
1784
            self._inventory_entry_cache.clear()
 
1785
            for repo in self._fallback_repositories:
 
1786
                repo.unlock()
264
1787
 
265
1788
    @needs_read_lock
266
 
    def clone(self, a_bzrdir, revision_id=None, basis=None):
 
1789
    def clone(self, a_bzrdir, revision_id=None):
267
1790
        """Clone this repository into a_bzrdir using the current format.
268
1791
 
269
1792
        Currently no check is made that the format of this repository and
270
1793
        the bzrdir format are compatible. FIXME RBC 20060201.
271
 
        """
 
1794
 
 
1795
        :return: The newly created destination repository.
 
1796
        """
 
1797
        # TODO: deprecate after 0.16; cloning this with all its settings is
 
1798
        # probably not very useful -- mbp 20070423
 
1799
        dest_repo = self._create_sprouting_repo(a_bzrdir, shared=self.is_shared())
 
1800
        self.copy_content_into(dest_repo, revision_id)
 
1801
        return dest_repo
 
1802
 
 
1803
    def start_write_group(self):
 
1804
        """Start a write group in the repository.
 
1805
 
 
1806
        Write groups are used by repositories which do not have a 1:1 mapping
 
1807
        between file ids and backend store to manage the insertion of data from
 
1808
        both fetch and commit operations.
 
1809
 
 
1810
        A write lock is required around the start_write_group/commit_write_group
 
1811
        for the support of lock-requiring repository formats.
 
1812
 
 
1813
        One can only insert data into a repository inside a write group.
 
1814
 
 
1815
        :return: None.
 
1816
        """
 
1817
        if not self.is_write_locked():
 
1818
            raise errors.NotWriteLocked(self)
 
1819
        if self._write_group:
 
1820
            raise errors.BzrError('already in a write group')
 
1821
        self._start_write_group()
 
1822
        # so we can detect unlock/relock - the write group is now entered.
 
1823
        self._write_group = self.get_transaction()
 
1824
 
 
1825
    def _start_write_group(self):
 
1826
        """Template method for per-repository write group startup.
 
1827
 
 
1828
        This is called before the write group is considered to be
 
1829
        entered.
 
1830
        """
 
1831
 
 
1832
    @needs_read_lock
 
1833
    def sprout(self, to_bzrdir, revision_id=None):
 
1834
        """Create a descendent repository for new development.
 
1835
 
 
1836
        Unlike clone, this does not copy the settings of the repository.
 
1837
        """
 
1838
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
 
1839
        dest_repo.fetch(self, revision_id=revision_id)
 
1840
        return dest_repo
 
1841
 
 
1842
    def _create_sprouting_repo(self, a_bzrdir, shared):
272
1843
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
273
1844
            # use target default format.
274
 
            result = a_bzrdir.create_repository()
275
 
        # FIXME RBC 20060209 split out the repository type to avoid this check ?
276
 
        elif isinstance(a_bzrdir._format,
277
 
                      (bzrdir.BzrDirFormat4,
278
 
                       bzrdir.BzrDirFormat5,
279
 
                       bzrdir.BzrDirFormat6)):
280
 
            result = a_bzrdir.open_repository()
 
1845
            dest_repo = a_bzrdir.create_repository()
281
1846
        else:
282
 
            result = self._format.initialize(a_bzrdir, shared=self.is_shared())
283
 
        self.copy_content_into(result, revision_id, basis)
284
 
        return result
 
1847
            # Most control formats need the repository to be specifically
 
1848
            # created, but on some old all-in-one formats it's not needed
 
1849
            try:
 
1850
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
 
1851
            except errors.UninitializableFormat:
 
1852
                dest_repo = a_bzrdir.open_repository()
 
1853
        return dest_repo
 
1854
 
 
1855
    def _get_sink(self):
 
1856
        """Return a sink for streaming into this repository."""
 
1857
        return StreamSink(self)
 
1858
 
 
1859
    def _get_source(self, to_format):
 
1860
        """Return a source for streaming from this repository."""
 
1861
        return StreamSource(self, to_format)
285
1862
 
286
1863
    @needs_read_lock
287
1864
    def has_revision(self, revision_id):
288
1865
        """True if this repository has a copy of the revision."""
289
 
        return self._revision_store.has_revision_id(revision_id,
290
 
                                                    self.get_transaction())
 
1866
        return revision_id in self.has_revisions((revision_id,))
 
1867
 
 
1868
    @needs_read_lock
 
1869
    def has_revisions(self, revision_ids):
 
1870
        """Probe to find out the presence of multiple revisions.
 
1871
 
 
1872
        :param revision_ids: An iterable of revision_ids.
 
1873
        :return: A set of the revision_ids that were present.
 
1874
        """
 
1875
        parent_map = self.revisions.get_parent_map(
 
1876
            [(rev_id,) for rev_id in revision_ids])
 
1877
        result = set()
 
1878
        if _mod_revision.NULL_REVISION in revision_ids:
 
1879
            result.add(_mod_revision.NULL_REVISION)
 
1880
        result.update([key[0] for key in parent_map])
 
1881
        return result
 
1882
 
 
1883
    @needs_read_lock
 
1884
    def get_revision(self, revision_id):
 
1885
        """Return the Revision object for a named revision."""
 
1886
        return self.get_revisions([revision_id])[0]
291
1887
 
292
1888
    @needs_read_lock
293
1889
    def get_revision_reconcile(self, revision_id):
294
1890
        """'reconcile' helper routine that allows access to a revision always.
295
 
        
 
1891
 
296
1892
        This variant of get_revision does not cross check the weave graph
297
1893
        against the revision one as get_revision does: but it should only
298
1894
        be used by reconcile, or reconcile-alike commands that are correcting
299
1895
        or testing the revision graph.
300
1896
        """
301
 
        if not revision_id or not isinstance(revision_id, basestring):
302
 
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
303
 
        return self._revision_store.get_revisions([revision_id],
304
 
                                                  self.get_transaction())[0]
 
1897
        return self._get_revisions([revision_id])[0]
 
1898
 
305
1899
    @needs_read_lock
306
1900
    def get_revisions(self, revision_ids):
307
 
        return self._revision_store.get_revisions(revision_ids,
308
 
                                                  self.get_transaction())
309
 
 
310
 
    @needs_read_lock
311
 
    def get_revision_xml(self, revision_id):
312
 
        rev = self.get_revision(revision_id) 
313
 
        rev_tmp = StringIO()
314
 
        # the current serializer..
315
 
        self._revision_store._serializer.write_revision(rev, rev_tmp)
316
 
        rev_tmp.seek(0)
317
 
        return rev_tmp.getvalue()
318
 
 
319
 
    @needs_read_lock
320
 
    def get_revision(self, revision_id):
321
 
        """Return the Revision object for a named revision"""
322
 
        r = self.get_revision_reconcile(revision_id)
323
 
        # weave corruption can lead to absent revision markers that should be
324
 
        # present.
325
 
        # the following test is reasonably cheap (it needs a single weave read)
326
 
        # and the weave is cached in read transactions. In write transactions
327
 
        # it is not cached but typically we only read a small number of
328
 
        # revisions. For knits when they are introduced we will probably want
329
 
        # to ensure that caching write transactions are in use.
330
 
        inv = self.get_inventory_weave()
331
 
        self._check_revision_parents(r, inv)
332
 
        return r
333
 
 
334
 
    @needs_read_lock
335
 
    def get_deltas_for_revisions(self, revisions):
 
1901
        """Get many revisions at once.
 
1902
        
 
1903
        Repositories that need to check data on every revision read should 
 
1904
        subclass this method.
 
1905
        """
 
1906
        return self._get_revisions(revision_ids)
 
1907
 
 
1908
    @needs_read_lock
 
1909
    def _get_revisions(self, revision_ids):
 
1910
        """Core work logic to get many revisions without sanity checks."""
 
1911
        revs = {}
 
1912
        for revid, rev in self._iter_revisions(revision_ids):
 
1913
            if rev is None:
 
1914
                raise errors.NoSuchRevision(self, revid)
 
1915
            revs[revid] = rev
 
1916
        return [revs[revid] for revid in revision_ids]
 
1917
 
 
1918
    def _iter_revisions(self, revision_ids):
 
1919
        """Iterate over revision objects.
 
1920
 
 
1921
        :param revision_ids: An iterable of revisions to examine. None may be
 
1922
            passed to request all revisions known to the repository. Note that
 
1923
            not all repositories can find unreferenced revisions; for those
 
1924
            repositories only referenced ones will be returned.
 
1925
        :return: An iterator of (revid, revision) tuples. Absent revisions (
 
1926
            those asked for but not available) are returned as (revid, None).
 
1927
        """
 
1928
        if revision_ids is None:
 
1929
            revision_ids = self.all_revision_ids()
 
1930
        else:
 
1931
            for rev_id in revision_ids:
 
1932
                if not rev_id or not isinstance(rev_id, basestring):
 
1933
                    raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
 
1934
        keys = [(key,) for key in revision_ids]
 
1935
        stream = self.revisions.get_record_stream(keys, 'unordered', True)
 
1936
        for record in stream:
 
1937
            revid = record.key[0]
 
1938
            if record.storage_kind == 'absent':
 
1939
                yield (revid, None)
 
1940
            else:
 
1941
                text = record.get_bytes_as('fulltext')
 
1942
                rev = self._serializer.read_revision_from_string(text)
 
1943
                yield (revid, rev)
 
1944
 
 
1945
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
336
1946
        """Produce a generator of revision deltas.
337
 
        
 
1947
 
338
1948
        Note that the input is a sequence of REVISIONS, not revision_ids.
339
1949
        Trees will be held in memory until the generator exits.
340
1950
        Each delta is relative to the revision's lefthand predecessor.
 
1951
 
 
1952
        :param specific_fileids: if not None, the result is filtered
 
1953
          so that only those file-ids, their parents and their
 
1954
          children are included.
341
1955
        """
 
1956
        # Get the revision-ids of interest
342
1957
        required_trees = set()
343
1958
        for revision in revisions:
344
1959
            required_trees.add(revision.revision_id)
345
1960
            required_trees.update(revision.parent_ids[:1])
346
 
        trees = dict((t.get_revision_id(), t) for 
347
 
                     t in self.revision_trees(required_trees))
 
1961
 
 
1962
        # Get the matching filtered trees. Note that it's more
 
1963
        # efficient to pass filtered trees to changes_from() rather
 
1964
        # than doing the filtering afterwards. changes_from() could
 
1965
        # arguably do the filtering itself but it's path-based, not
 
1966
        # file-id based, so filtering before or afterwards is
 
1967
        # currently easier.
 
1968
        if specific_fileids is None:
 
1969
            trees = dict((t.get_revision_id(), t) for
 
1970
                t in self.revision_trees(required_trees))
 
1971
        else:
 
1972
            trees = dict((t.get_revision_id(), t) for
 
1973
                t in self._filtered_revision_trees(required_trees,
 
1974
                specific_fileids))
 
1975
 
 
1976
        # Calculate the deltas
348
1977
        for revision in revisions:
349
1978
            if not revision.parent_ids:
350
 
                old_tree = EmptyTree()
 
1979
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
351
1980
            else:
352
1981
                old_tree = trees[revision.parent_ids[0]]
353
 
            yield delta.compare_trees(old_tree, trees[revision.revision_id])
 
1982
            yield trees[revision.revision_id].changes_from(old_tree)
354
1983
 
355
1984
    @needs_read_lock
356
 
    def get_revision_delta(self, revision_id):
 
1985
    def get_revision_delta(self, revision_id, specific_fileids=None):
357
1986
        """Return the delta for one revision.
358
1987
 
359
1988
        The delta is relative to the left-hand predecessor of the
360
1989
        revision.
 
1990
 
 
1991
        :param specific_fileids: if not None, the result is filtered
 
1992
          so that only those file-ids, their parents and their
 
1993
          children are included.
361
1994
        """
362
1995
        r = self.get_revision(revision_id)
363
 
        return list(self.get_deltas_for_revisions([r]))[0]
364
 
 
365
 
    def _check_revision_parents(self, revision, inventory):
366
 
        """Private to Repository and Fetch.
367
 
        
368
 
        This checks the parentage of revision in an inventory weave for 
369
 
        consistency and is only applicable to inventory-weave-for-ancestry
370
 
        using repository formats & fetchers.
371
 
        """
372
 
        weave_parents = inventory.get_parents(revision.revision_id)
373
 
        weave_names = inventory.versions()
374
 
        for parent_id in revision.parent_ids:
375
 
            if parent_id in weave_names:
376
 
                # this parent must not be a ghost.
377
 
                if not parent_id in weave_parents:
378
 
                    # but it is a ghost
379
 
                    raise errors.CorruptRepository(self)
 
1996
        return list(self.get_deltas_for_revisions([r],
 
1997
            specific_fileids=specific_fileids))[0]
380
1998
 
381
1999
    @needs_write_lock
382
2000
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
383
2001
        signature = gpg_strategy.sign(plaintext)
384
 
        self._revision_store.add_revision_signature_text(revision_id,
385
 
                                                         signature,
386
 
                                                         self.get_transaction())
387
 
 
388
 
    def fileids_altered_by_revision_ids(self, revision_ids):
389
 
        """Find the file ids and versions affected by revisions.
390
 
 
391
 
        :param revisions: an iterable containing revision ids.
392
 
        :return: a dictionary mapping altered file-ids to an iterable of
393
 
        revision_ids. Each altered file-ids has the exact revision_ids that
394
 
        altered it listed explicitly.
395
 
        """
396
 
        assert isinstance(self._format, (RepositoryFormat5,
397
 
                                         RepositoryFormat6,
398
 
                                         RepositoryFormat7,
399
 
                                         RepositoryFormatKnit1)), \
400
 
            ("fileids_altered_by_revision_ids only supported for branches " 
401
 
             "which store inventory as unnested xml, not on %r" % self)
402
 
        selected_revision_ids = set(revision_ids)
403
 
        w = self.get_inventory_weave()
 
2002
        self.add_signature_text(revision_id, signature)
 
2003
 
 
2004
    @needs_write_lock
 
2005
    def add_signature_text(self, revision_id, signature):
 
2006
        self.signatures.add_lines((revision_id,), (),
 
2007
            osutils.split_lines(signature))
 
2008
 
 
2009
    def find_text_key_references(self):
 
2010
        """Find the text key references within the repository.
 
2011
 
 
2012
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
 
2013
            to whether they were referred to by the inventory of the
 
2014
            revision_id that they contain. The inventory texts from all present
 
2015
            revision ids are assessed to generate this report.
 
2016
        """
 
2017
        revision_keys = self.revisions.keys()
 
2018
        w = self.inventories
 
2019
        pb = ui.ui_factory.nested_progress_bar()
 
2020
        try:
 
2021
            return self._find_text_key_references_from_xml_inventory_lines(
 
2022
                w.iter_lines_added_or_present_in_keys(revision_keys, pb=pb))
 
2023
        finally:
 
2024
            pb.finished()
 
2025
 
 
2026
    def _find_text_key_references_from_xml_inventory_lines(self,
 
2027
        line_iterator):
 
2028
        """Core routine for extracting references to texts from inventories.
 
2029
 
 
2030
        This performs the translation of xml lines to revision ids.
 
2031
 
 
2032
        :param line_iterator: An iterator of lines, origin_version_id
 
2033
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
 
2034
            to whether they were referred to by the inventory of the
 
2035
            revision_id that they contain. Note that if that revision_id was
 
2036
            not part of the line_iterator's output then False will be given -
 
2037
            even though it may actually refer to that key.
 
2038
        """
 
2039
        if not self._serializer.support_altered_by_hack:
 
2040
            raise AssertionError(
 
2041
                "_find_text_key_references_from_xml_inventory_lines only "
 
2042
                "supported for branches which store inventory as unnested xml"
 
2043
                ", not on %r" % self)
404
2044
        result = {}
405
2045
 
406
2046
        # this code needs to read every new line in every inventory for the
407
2047
        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
408
 
        # not present in one of those inventories is unnecessary but not 
 
2048
        # not present in one of those inventories is unnecessary but not
409
2049
        # harmful because we are filtering by the revision id marker in the
410
 
        # inventory lines : we only select file ids altered in one of those  
 
2050
        # inventory lines : we only select file ids altered in one of those
411
2051
        # revisions. We don't need to see all lines in the inventory because
412
2052
        # only those added in an inventory in rev X can contain a revision=X
413
2053
        # line.
414
 
        for line in w.iter_lines_added_or_present_in_versions(selected_revision_ids):
415
 
            start = line.find('file_id="')+9
416
 
            if start < 9: continue
417
 
            end = line.find('"', start)
418
 
            assert end>= 0
419
 
            file_id = _unescape_xml(line[start:end])
420
 
 
421
 
            start = line.find('revision="')+10
422
 
            if start < 10: continue
423
 
            end = line.find('"', start)
424
 
            assert end>= 0
425
 
            revision_id = _unescape_xml(line[start:end])
426
 
            if revision_id in selected_revision_ids:
427
 
                result.setdefault(file_id, set()).add(revision_id)
428
 
        return result
429
 
 
430
 
    @needs_read_lock
431
 
    def get_inventory_weave(self):
432
 
        return self.control_weaves.get_weave('inventory',
433
 
            self.get_transaction())
 
2054
        unescape_revid_cache = {}
 
2055
        unescape_fileid_cache = {}
 
2056
 
 
2057
        # jam 20061218 In a big fetch, this handles hundreds of thousands
 
2058
        # of lines, so it has had a lot of inlining and optimizing done.
 
2059
        # Sorry that it is a little bit messy.
 
2060
        # Move several functions to be local variables, since this is a long
 
2061
        # running loop.
 
2062
        search = self._file_ids_altered_regex.search
 
2063
        unescape = _unescape_xml
 
2064
        setdefault = result.setdefault
 
2065
        for line, line_key in line_iterator:
 
2066
            match = search(line)
 
2067
            if match is None:
 
2068
                continue
 
2069
            # One call to match.group() returning multiple items is quite a
 
2070
            # bit faster than 2 calls to match.group() each returning 1
 
2071
            file_id, revision_id = match.group('file_id', 'revision_id')
 
2072
 
 
2073
            # Inlining the cache lookups helps a lot when you make 170,000
 
2074
            # lines and 350k ids, versus 8.4 unique ids.
 
2075
            # Using a cache helps in 2 ways:
 
2076
            #   1) Avoids unnecessary decoding calls
 
2077
            #   2) Re-uses cached strings, which helps in future set and
 
2078
            #      equality checks.
 
2079
            # (2) is enough that removing encoding entirely along with
 
2080
            # the cache (so we are using plain strings) results in no
 
2081
            # performance improvement.
 
2082
            try:
 
2083
                revision_id = unescape_revid_cache[revision_id]
 
2084
            except KeyError:
 
2085
                unescaped = unescape(revision_id)
 
2086
                unescape_revid_cache[revision_id] = unescaped
 
2087
                revision_id = unescaped
 
2088
 
 
2089
            # Note that unconditionally unescaping means that we deserialise
 
2090
            # every fileid, which for general 'pull' is not great, but we don't
 
2091
            # really want to have some many fulltexts that this matters anyway.
 
2092
            # RBC 20071114.
 
2093
            try:
 
2094
                file_id = unescape_fileid_cache[file_id]
 
2095
            except KeyError:
 
2096
                unescaped = unescape(file_id)
 
2097
                unescape_fileid_cache[file_id] = unescaped
 
2098
                file_id = unescaped
 
2099
 
 
2100
            key = (file_id, revision_id)
 
2101
            setdefault(key, False)
 
2102
            if revision_id == line_key[-1]:
 
2103
                result[key] = True
 
2104
        return result
 
2105
 
 
2106
    def _inventory_xml_lines_for_keys(self, keys):
 
2107
        """Get a line iterator of the sort needed for findind references.
 
2108
 
 
2109
        Not relevant for non-xml inventory repositories.
 
2110
 
 
2111
        Ghosts in revision_keys are ignored.
 
2112
 
 
2113
        :param revision_keys: The revision keys for the inventories to inspect.
 
2114
        :return: An iterator over (inventory line, revid) for the fulltexts of
 
2115
            all of the xml inventories specified by revision_keys.
 
2116
        """
 
2117
        stream = self.inventories.get_record_stream(keys, 'unordered', True)
 
2118
        for record in stream:
 
2119
            if record.storage_kind != 'absent':
 
2120
                chunks = record.get_bytes_as('chunked')
 
2121
                revid = record.key[-1]
 
2122
                lines = osutils.chunks_to_lines(chunks)
 
2123
                for line in lines:
 
2124
                    yield line, revid
 
2125
 
 
2126
    def _find_file_ids_from_xml_inventory_lines(self, line_iterator,
 
2127
        revision_keys):
 
2128
        """Helper routine for fileids_altered_by_revision_ids.
 
2129
 
 
2130
        This performs the translation of xml lines to revision ids.
 
2131
 
 
2132
        :param line_iterator: An iterator of lines, origin_version_id
 
2133
        :param revision_keys: The revision ids to filter for. This should be a
 
2134
            set or other type which supports efficient __contains__ lookups, as
 
2135
            the revision key from each parsed line will be looked up in the
 
2136
            revision_keys filter.
 
2137
        :return: a dictionary mapping altered file-ids to an iterable of
 
2138
        revision_ids. Each altered file-ids has the exact revision_ids that
 
2139
        altered it listed explicitly.
 
2140
        """
 
2141
        seen = set(self._find_text_key_references_from_xml_inventory_lines(
 
2142
                line_iterator).iterkeys())
 
2143
        parent_keys = self._find_parent_keys_of_revisions(revision_keys)
 
2144
        parent_seen = set(self._find_text_key_references_from_xml_inventory_lines(
 
2145
            self._inventory_xml_lines_for_keys(parent_keys)))
 
2146
        new_keys = seen - parent_seen
 
2147
        result = {}
 
2148
        setdefault = result.setdefault
 
2149
        for key in new_keys:
 
2150
            setdefault(key[0], set()).add(key[-1])
 
2151
        return result
 
2152
 
 
2153
    def _find_parent_ids_of_revisions(self, revision_ids):
 
2154
        """Find all parent ids that are mentioned in the revision graph.
 
2155
 
 
2156
        :return: set of revisions that are parents of revision_ids which are
 
2157
            not part of revision_ids themselves
 
2158
        """
 
2159
        parent_map = self.get_parent_map(revision_ids)
 
2160
        parent_ids = set()
 
2161
        map(parent_ids.update, parent_map.itervalues())
 
2162
        parent_ids.difference_update(revision_ids)
 
2163
        parent_ids.discard(_mod_revision.NULL_REVISION)
 
2164
        return parent_ids
 
2165
 
 
2166
    def _find_parent_keys_of_revisions(self, revision_keys):
 
2167
        """Similar to _find_parent_ids_of_revisions, but used with keys.
 
2168
 
 
2169
        :param revision_keys: An iterable of revision_keys.
 
2170
        :return: The parents of all revision_keys that are not already in
 
2171
            revision_keys
 
2172
        """
 
2173
        parent_map = self.revisions.get_parent_map(revision_keys)
 
2174
        parent_keys = set()
 
2175
        map(parent_keys.update, parent_map.itervalues())
 
2176
        parent_keys.difference_update(revision_keys)
 
2177
        parent_keys.discard(_mod_revision.NULL_REVISION)
 
2178
        return parent_keys
 
2179
 
 
2180
    def fileids_altered_by_revision_ids(self, revision_ids, _inv_weave=None):
 
2181
        """Find the file ids and versions affected by revisions.
 
2182
 
 
2183
        :param revisions: an iterable containing revision ids.
 
2184
        :param _inv_weave: The inventory weave from this repository or None.
 
2185
            If None, the inventory weave will be opened automatically.
 
2186
        :return: a dictionary mapping altered file-ids to an iterable of
 
2187
        revision_ids. Each altered file-ids has the exact revision_ids that
 
2188
        altered it listed explicitly.
 
2189
        """
 
2190
        selected_keys = set((revid,) for revid in revision_ids)
 
2191
        w = _inv_weave or self.inventories
 
2192
        return self._find_file_ids_from_xml_inventory_lines(
 
2193
            w.iter_lines_added_or_present_in_keys(
 
2194
                selected_keys, pb=None),
 
2195
            selected_keys)
 
2196
 
 
2197
    def iter_files_bytes(self, desired_files):
 
2198
        """Iterate through file versions.
 
2199
 
 
2200
        Files will not necessarily be returned in the order they occur in
 
2201
        desired_files.  No specific order is guaranteed.
 
2202
 
 
2203
        Yields pairs of identifier, bytes_iterator.  identifier is an opaque
 
2204
        value supplied by the caller as part of desired_files.  It should
 
2205
        uniquely identify the file version in the caller's context.  (Examples:
 
2206
        an index number or a TreeTransform trans_id.)
 
2207
 
 
2208
        bytes_iterator is an iterable of bytestrings for the file.  The
 
2209
        kind of iterable and length of the bytestrings are unspecified, but for
 
2210
        this implementation, it is a list of bytes produced by
 
2211
        VersionedFile.get_record_stream().
 
2212
 
 
2213
        :param desired_files: a list of (file_id, revision_id, identifier)
 
2214
            triples
 
2215
        """
 
2216
        text_keys = {}
 
2217
        for file_id, revision_id, callable_data in desired_files:
 
2218
            text_keys[(file_id, revision_id)] = callable_data
 
2219
        for record in self.texts.get_record_stream(text_keys, 'unordered', True):
 
2220
            if record.storage_kind == 'absent':
 
2221
                raise errors.RevisionNotPresent(record.key, self)
 
2222
            yield text_keys[record.key], record.get_bytes_as('chunked')
 
2223
 
 
2224
    def _generate_text_key_index(self, text_key_references=None,
 
2225
        ancestors=None):
 
2226
        """Generate a new text key index for the repository.
 
2227
 
 
2228
        This is an expensive function that will take considerable time to run.
 
2229
 
 
2230
        :return: A dict mapping text keys ((file_id, revision_id) tuples) to a
 
2231
            list of parents, also text keys. When a given key has no parents,
 
2232
            the parents list will be [NULL_REVISION].
 
2233
        """
 
2234
        # All revisions, to find inventory parents.
 
2235
        if ancestors is None:
 
2236
            graph = self.get_graph()
 
2237
            ancestors = graph.get_parent_map(self.all_revision_ids())
 
2238
        if text_key_references is None:
 
2239
            text_key_references = self.find_text_key_references()
 
2240
        pb = ui.ui_factory.nested_progress_bar()
 
2241
        try:
 
2242
            return self._do_generate_text_key_index(ancestors,
 
2243
                text_key_references, pb)
 
2244
        finally:
 
2245
            pb.finished()
 
2246
 
 
2247
    def _do_generate_text_key_index(self, ancestors, text_key_references, pb):
 
2248
        """Helper for _generate_text_key_index to avoid deep nesting."""
 
2249
        revision_order = tsort.topo_sort(ancestors)
 
2250
        invalid_keys = set()
 
2251
        revision_keys = {}
 
2252
        for revision_id in revision_order:
 
2253
            revision_keys[revision_id] = set()
 
2254
        text_count = len(text_key_references)
 
2255
        # a cache of the text keys to allow reuse; costs a dict of all the
 
2256
        # keys, but saves a 2-tuple for every child of a given key.
 
2257
        text_key_cache = {}
 
2258
        for text_key, valid in text_key_references.iteritems():
 
2259
            if not valid:
 
2260
                invalid_keys.add(text_key)
 
2261
            else:
 
2262
                revision_keys[text_key[1]].add(text_key)
 
2263
            text_key_cache[text_key] = text_key
 
2264
        del text_key_references
 
2265
        text_index = {}
 
2266
        text_graph = graph.Graph(graph.DictParentsProvider(text_index))
 
2267
        NULL_REVISION = _mod_revision.NULL_REVISION
 
2268
        # Set a cache with a size of 10 - this suffices for bzr.dev but may be
 
2269
        # too small for large or very branchy trees. However, for 55K path
 
2270
        # trees, it would be easy to use too much memory trivially. Ideally we
 
2271
        # could gauge this by looking at available real memory etc, but this is
 
2272
        # always a tricky proposition.
 
2273
        inventory_cache = lru_cache.LRUCache(10)
 
2274
        batch_size = 10 # should be ~150MB on a 55K path tree
 
2275
        batch_count = len(revision_order) / batch_size + 1
 
2276
        processed_texts = 0
 
2277
        pb.update("Calculating text parents", processed_texts, text_count)
 
2278
        for offset in xrange(batch_count):
 
2279
            to_query = revision_order[offset * batch_size:(offset + 1) *
 
2280
                batch_size]
 
2281
            if not to_query:
 
2282
                break
 
2283
            for revision_id in to_query:
 
2284
                parent_ids = ancestors[revision_id]
 
2285
                for text_key in revision_keys[revision_id]:
 
2286
                    pb.update("Calculating text parents", processed_texts)
 
2287
                    processed_texts += 1
 
2288
                    candidate_parents = []
 
2289
                    for parent_id in parent_ids:
 
2290
                        parent_text_key = (text_key[0], parent_id)
 
2291
                        try:
 
2292
                            check_parent = parent_text_key not in \
 
2293
                                revision_keys[parent_id]
 
2294
                        except KeyError:
 
2295
                            # the parent parent_id is a ghost:
 
2296
                            check_parent = False
 
2297
                            # truncate the derived graph against this ghost.
 
2298
                            parent_text_key = None
 
2299
                        if check_parent:
 
2300
                            # look at the parent commit details inventories to
 
2301
                            # determine possible candidates in the per file graph.
 
2302
                            # TODO: cache here.
 
2303
                            try:
 
2304
                                inv = inventory_cache[parent_id]
 
2305
                            except KeyError:
 
2306
                                inv = self.revision_tree(parent_id).inventory
 
2307
                                inventory_cache[parent_id] = inv
 
2308
                            try:
 
2309
                                parent_entry = inv[text_key[0]]
 
2310
                            except (KeyError, errors.NoSuchId):
 
2311
                                parent_entry = None
 
2312
                            if parent_entry is not None:
 
2313
                                parent_text_key = (
 
2314
                                    text_key[0], parent_entry.revision)
 
2315
                            else:
 
2316
                                parent_text_key = None
 
2317
                        if parent_text_key is not None:
 
2318
                            candidate_parents.append(
 
2319
                                text_key_cache[parent_text_key])
 
2320
                    parent_heads = text_graph.heads(candidate_parents)
 
2321
                    new_parents = list(parent_heads)
 
2322
                    new_parents.sort(key=lambda x:candidate_parents.index(x))
 
2323
                    if new_parents == []:
 
2324
                        new_parents = [NULL_REVISION]
 
2325
                    text_index[text_key] = new_parents
 
2326
 
 
2327
        for text_key in invalid_keys:
 
2328
            text_index[text_key] = [NULL_REVISION]
 
2329
        return text_index
 
2330
 
 
2331
    def item_keys_introduced_by(self, revision_ids, _files_pb=None):
 
2332
        """Get an iterable listing the keys of all the data introduced by a set
 
2333
        of revision IDs.
 
2334
 
 
2335
        The keys will be ordered so that the corresponding items can be safely
 
2336
        fetched and inserted in that order.
 
2337
 
 
2338
        :returns: An iterable producing tuples of (knit-kind, file-id,
 
2339
            versions).  knit-kind is one of 'file', 'inventory', 'signatures',
 
2340
            'revisions'.  file-id is None unless knit-kind is 'file'.
 
2341
        """
 
2342
        for result in self._find_file_keys_to_fetch(revision_ids, _files_pb):
 
2343
            yield result
 
2344
        del _files_pb
 
2345
        for result in self._find_non_file_keys_to_fetch(revision_ids):
 
2346
            yield result
 
2347
 
 
2348
    def _find_file_keys_to_fetch(self, revision_ids, pb):
 
2349
        # XXX: it's a bit weird to control the inventory weave caching in this
 
2350
        # generator.  Ideally the caching would be done in fetch.py I think.  Or
 
2351
        # maybe this generator should explicitly have the contract that it
 
2352
        # should not be iterated until the previously yielded item has been
 
2353
        # processed?
 
2354
        inv_w = self.inventories
 
2355
 
 
2356
        # file ids that changed
 
2357
        file_ids = self.fileids_altered_by_revision_ids(revision_ids, inv_w)
 
2358
        count = 0
 
2359
        num_file_ids = len(file_ids)
 
2360
        for file_id, altered_versions in file_ids.iteritems():
 
2361
            if pb is not None:
 
2362
                pb.update("Fetch texts", count, num_file_ids)
 
2363
            count += 1
 
2364
            yield ("file", file_id, altered_versions)
 
2365
 
 
2366
    def _find_non_file_keys_to_fetch(self, revision_ids):
 
2367
        # inventory
 
2368
        yield ("inventory", None, revision_ids)
 
2369
 
 
2370
        # signatures
 
2371
        # XXX: Note ATM no callers actually pay attention to this return
 
2372
        #      instead they just use the list of revision ids and ignore
 
2373
        #      missing sigs. Consider removing this work entirely
 
2374
        revisions_with_signatures = set(self.signatures.get_parent_map(
 
2375
            [(r,) for r in revision_ids]))
 
2376
        revisions_with_signatures = set(
 
2377
            [r for (r,) in revisions_with_signatures])
 
2378
        revisions_with_signatures.intersection_update(revision_ids)
 
2379
        yield ("signatures", None, revisions_with_signatures)
 
2380
 
 
2381
        # revisions
 
2382
        yield ("revisions", None, revision_ids)
434
2383
 
435
2384
    @needs_read_lock
436
2385
    def get_inventory(self, revision_id):
437
 
        """Get Inventory object by hash."""
438
 
        return self.deserialise_inventory(
439
 
            revision_id, self.get_inventory_xml(revision_id))
440
 
 
441
 
    def deserialise_inventory(self, revision_id, xml):
442
 
        """Transform the xml into an inventory object. 
 
2386
        """Get Inventory object by revision id."""
 
2387
        return self.iter_inventories([revision_id]).next()
 
2388
 
 
2389
    def iter_inventories(self, revision_ids, ordering=None):
 
2390
        """Get many inventories by revision_ids.
 
2391
 
 
2392
        This will buffer some or all of the texts used in constructing the
 
2393
        inventories in memory, but will only parse a single inventory at a
 
2394
        time.
 
2395
 
 
2396
        :param revision_ids: The expected revision ids of the inventories.
 
2397
        :param ordering: optional ordering, e.g. 'topological'.  If not
 
2398
            specified, the order of revision_ids will be preserved (by
 
2399
            buffering if necessary).
 
2400
        :return: An iterator of inventories.
 
2401
        """
 
2402
        if ((None in revision_ids)
 
2403
            or (_mod_revision.NULL_REVISION in revision_ids)):
 
2404
            raise ValueError('cannot get null revision inventory')
 
2405
        return self._iter_inventories(revision_ids, ordering)
 
2406
 
 
2407
    def _iter_inventories(self, revision_ids, ordering):
 
2408
        """single-document based inventory iteration."""
 
2409
        inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
 
2410
        for text, revision_id in inv_xmls:
 
2411
            yield self._deserialise_inventory(revision_id, text)
 
2412
 
 
2413
    def _iter_inventory_xmls(self, revision_ids, ordering):
 
2414
        if ordering is None:
 
2415
            order_as_requested = True
 
2416
            ordering = 'unordered'
 
2417
        else:
 
2418
            order_as_requested = False
 
2419
        keys = [(revision_id,) for revision_id in revision_ids]
 
2420
        if not keys:
 
2421
            return
 
2422
        if order_as_requested:
 
2423
            key_iter = iter(keys)
 
2424
            next_key = key_iter.next()
 
2425
        stream = self.inventories.get_record_stream(keys, ordering, True)
 
2426
        text_chunks = {}
 
2427
        for record in stream:
 
2428
            if record.storage_kind != 'absent':
 
2429
                chunks = record.get_bytes_as('chunked')
 
2430
                if order_as_requested:
 
2431
                    text_chunks[record.key] = chunks
 
2432
                else:
 
2433
                    yield ''.join(chunks), record.key[-1]
 
2434
            else:
 
2435
                raise errors.NoSuchRevision(self, record.key)
 
2436
            if order_as_requested:
 
2437
                # Yield as many results as we can while preserving order.
 
2438
                while next_key in text_chunks:
 
2439
                    chunks = text_chunks.pop(next_key)
 
2440
                    yield ''.join(chunks), next_key[-1]
 
2441
                    try:
 
2442
                        next_key = key_iter.next()
 
2443
                    except StopIteration:
 
2444
                        # We still want to fully consume the get_record_stream,
 
2445
                        # just in case it is not actually finished at this point
 
2446
                        next_key = None
 
2447
                        break
 
2448
 
 
2449
    def _deserialise_inventory(self, revision_id, xml):
 
2450
        """Transform the xml into an inventory object.
443
2451
 
444
2452
        :param revision_id: The expected revision id of the inventory.
445
2453
        :param xml: A serialised inventory.
446
2454
        """
447
 
        return xml5.serializer_v5.read_inventory_from_string(xml)
 
2455
        result = self._serializer.read_inventory_from_string(xml, revision_id,
 
2456
                    entry_cache=self._inventory_entry_cache,
 
2457
                    return_from_cache=self._safe_to_return_from_cache)
 
2458
        if result.revision_id != revision_id:
 
2459
            raise AssertionError('revision id mismatch %s != %s' % (
 
2460
                result.revision_id, revision_id))
 
2461
        return result
 
2462
 
 
2463
    def get_serializer_format(self):
 
2464
        return self._serializer.format_num
448
2465
 
449
2466
    @needs_read_lock
450
 
    def get_inventory_xml(self, revision_id):
451
 
        """Get inventory XML as a file object."""
 
2467
    def _get_inventory_xml(self, revision_id):
 
2468
        """Get serialized inventory as a string."""
 
2469
        texts = self._iter_inventory_xmls([revision_id], 'unordered')
452
2470
        try:
453
 
            assert isinstance(revision_id, basestring), type(revision_id)
454
 
            iw = self.get_inventory_weave()
455
 
            return iw.get_text(revision_id)
456
 
        except IndexError:
 
2471
            text, revision_id = texts.next()
 
2472
        except StopIteration:
457
2473
            raise errors.HistoryMissing(self, 'inventory', revision_id)
458
 
 
459
 
    @needs_read_lock
460
 
    def get_inventory_sha1(self, revision_id):
461
 
        """Return the sha1 hash of the inventory entry
462
 
        """
463
 
        return self.get_revision(revision_id).inventory_sha1
464
 
 
465
 
    @needs_read_lock
466
 
    def get_revision_graph(self, revision_id=None):
467
 
        """Return a dictionary containing the revision graph.
468
 
        
469
 
        :param revision_id: The revision_id to get a graph from. If None, then
470
 
        the entire revision graph is returned. This is a deprecated mode of
471
 
        operation and will be removed in the future.
472
 
        :return: a dictionary of revision_id->revision_parents_list.
473
 
        """
474
 
        # special case NULL_REVISION
475
 
        if revision_id == NULL_REVISION:
476
 
            return {}
477
 
        weave = self.get_inventory_weave()
478
 
        all_revisions = self._eliminate_revisions_not_present(weave.versions())
479
 
        entire_graph = dict([(node, weave.get_parents(node)) for 
480
 
                             node in all_revisions])
481
 
        if revision_id is None:
482
 
            return entire_graph
483
 
        elif revision_id not in entire_graph:
484
 
            raise errors.NoSuchRevision(self, revision_id)
485
 
        else:
486
 
            # add what can be reached from revision_id
487
 
            result = {}
488
 
            pending = set([revision_id])
489
 
            while len(pending) > 0:
490
 
                node = pending.pop()
491
 
                result[node] = entire_graph[node]
492
 
                for revision_id in result[node]:
493
 
                    if revision_id not in result:
494
 
                        pending.add(revision_id)
495
 
            return result
496
 
 
497
 
    @needs_read_lock
498
 
    def get_revision_graph_with_ghosts(self, revision_ids=None):
499
 
        """Return a graph of the revisions with ghosts marked as applicable.
500
 
 
501
 
        :param revision_ids: an iterable of revisions to graph or None for all.
502
 
        :return: a Graph object with the graph reachable from revision_ids.
503
 
        """
504
 
        result = Graph()
505
 
        if not revision_ids:
506
 
            pending = set(self.all_revision_ids())
507
 
            required = set([])
508
 
        else:
509
 
            pending = set(revision_ids)
510
 
            # special case NULL_REVISION
511
 
            if NULL_REVISION in pending:
512
 
                pending.remove(NULL_REVISION)
513
 
            required = set(pending)
514
 
        done = set([])
515
 
        while len(pending):
516
 
            revision_id = pending.pop()
517
 
            try:
518
 
                rev = self.get_revision(revision_id)
519
 
            except errors.NoSuchRevision:
520
 
                if revision_id in required:
521
 
                    raise
522
 
                # a ghost
523
 
                result.add_ghost(revision_id)
524
 
                continue
525
 
            for parent_id in rev.parent_ids:
526
 
                # is this queued or done ?
527
 
                if (parent_id not in pending and
528
 
                    parent_id not in done):
529
 
                    # no, queue it.
530
 
                    pending.add(parent_id)
531
 
            result.add_node(revision_id, rev.parent_ids)
532
 
            done.add(revision_id)
533
 
        return result
534
 
 
535
 
    @needs_read_lock
536
 
    def get_revision_inventory(self, revision_id):
537
 
        """Return inventory of a past revision."""
538
 
        # TODO: Unify this with get_inventory()
539
 
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
540
 
        # must be the same as its revision, so this is trivial.
541
 
        if revision_id is None:
542
 
            # This does not make sense: if there is no revision,
543
 
            # then it is the current tree inventory surely ?!
544
 
            # and thus get_root_id() is something that looks at the last
545
 
            # commit on the branch, and the get_root_id is an inventory check.
546
 
            raise NotImplementedError
547
 
            # return Inventory(self.get_root_id())
548
 
        else:
549
 
            return self.get_inventory(revision_id)
550
 
 
551
 
    @needs_read_lock
 
2474
        return text
 
2475
 
 
2476
    def get_rev_id_for_revno(self, revno, known_pair):
 
2477
        """Return the revision id of a revno, given a later (revno, revid)
 
2478
        pair in the same history.
 
2479
 
 
2480
        :return: if found (True, revid).  If the available history ran out
 
2481
            before reaching the revno, then this returns
 
2482
            (False, (closest_revno, closest_revid)).
 
2483
        """
 
2484
        known_revno, known_revid = known_pair
 
2485
        partial_history = [known_revid]
 
2486
        distance_from_known = known_revno - revno
 
2487
        if distance_from_known < 0:
 
2488
            raise ValueError(
 
2489
                'requested revno (%d) is later than given known revno (%d)'
 
2490
                % (revno, known_revno))
 
2491
        try:
 
2492
            _iter_for_revno(
 
2493
                self, partial_history, stop_index=distance_from_known)
 
2494
        except errors.RevisionNotPresent, err:
 
2495
            if err.revision_id == known_revid:
 
2496
                # The start revision (known_revid) wasn't found.
 
2497
                raise
 
2498
            # This is a stacked repository with no fallbacks, or a there's a
 
2499
            # left-hand ghost.  Either way, even though the revision named in
 
2500
            # the error isn't in this repo, we know it's the next step in this
 
2501
            # left-hand history.
 
2502
            partial_history.append(err.revision_id)
 
2503
        if len(partial_history) <= distance_from_known:
 
2504
            # Didn't find enough history to get a revid for the revno.
 
2505
            earliest_revno = known_revno - len(partial_history) + 1
 
2506
            return (False, (earliest_revno, partial_history[-1]))
 
2507
        if len(partial_history) - 1 > distance_from_known:
 
2508
            raise AssertionError('_iter_for_revno returned too much history')
 
2509
        return (True, partial_history[-1])
 
2510
 
 
2511
    def iter_reverse_revision_history(self, revision_id):
 
2512
        """Iterate backwards through revision ids in the lefthand history
 
2513
 
 
2514
        :param revision_id: The revision id to start with.  All its lefthand
 
2515
            ancestors will be traversed.
 
2516
        """
 
2517
        graph = self.get_graph()
 
2518
        stop_revisions = (None, _mod_revision.NULL_REVISION)
 
2519
        return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
 
2520
 
552
2521
    def is_shared(self):
553
2522
        """Return True if this repository is flagged as a shared repository."""
554
2523
        raise NotImplementedError(self.is_shared)
560
2529
        reconciler = RepoReconciler(self, thorough=thorough)
561
2530
        reconciler.reconcile()
562
2531
        return reconciler
563
 
    
 
2532
 
 
2533
    def _refresh_data(self):
 
2534
        """Helper called from lock_* to ensure coherency with disk.
 
2535
 
 
2536
        The default implementation does nothing; it is however possible
 
2537
        for repositories to maintain loaded indices across multiple locks
 
2538
        by checking inside their implementation of this method to see
 
2539
        whether their indices are still valid. This depends of course on
 
2540
        the disk format being validatable in this manner. This method is
 
2541
        also called by the refresh_data() public interface to cause a refresh
 
2542
        to occur while in a write lock so that data inserted by a smart server
 
2543
        push operation is visible on the client's instance of the physical
 
2544
        repository.
 
2545
        """
 
2546
 
564
2547
    @needs_read_lock
565
2548
    def revision_tree(self, revision_id):
566
2549
        """Return Tree for a revision on this branch.
567
2550
 
568
 
        `revision_id` may be None for the null revision, in which case
569
 
        an `EmptyTree` is returned."""
 
2551
        `revision_id` may be NULL_REVISION for the empty tree revision.
 
2552
        """
 
2553
        revision_id = _mod_revision.ensure_null(revision_id)
570
2554
        # TODO: refactor this to use an existing revision object
571
2555
        # so we don't need to read it in twice.
572
 
        if revision_id is None or revision_id == NULL_REVISION:
573
 
            return EmptyTree()
 
2556
        if revision_id == _mod_revision.NULL_REVISION:
 
2557
            return RevisionTree(self, Inventory(root_id=None),
 
2558
                                _mod_revision.NULL_REVISION)
574
2559
        else:
575
 
            inv = self.get_revision_inventory(revision_id)
 
2560
            inv = self.get_inventory(revision_id)
576
2561
            return RevisionTree(self, inv, revision_id)
577
2562
 
578
 
    @needs_read_lock
579
2563
    def revision_trees(self, revision_ids):
580
 
        """Return Tree for a revision on this branch.
581
 
 
582
 
        `revision_id` may not be None or 'null:'"""
583
 
        assert None not in revision_ids
584
 
        assert NULL_REVISION not in revision_ids
585
 
        texts = self.get_inventory_weave().get_texts(revision_ids)
586
 
        for text, revision_id in zip(texts, revision_ids):
587
 
            inv = self.deserialise_inventory(revision_id, text)
588
 
            yield RevisionTree(self, inv, revision_id)
 
2564
        """Return Trees for revisions in this repository.
 
2565
 
 
2566
        :param revision_ids: a sequence of revision-ids;
 
2567
          a revision-id may not be None or 'null:'
 
2568
        """
 
2569
        inventories = self.iter_inventories(revision_ids)
 
2570
        for inv in inventories:
 
2571
            yield RevisionTree(self, inv, inv.revision_id)
 
2572
 
 
2573
    def _filtered_revision_trees(self, revision_ids, file_ids):
 
2574
        """Return Tree for a revision on this branch with only some files.
 
2575
 
 
2576
        :param revision_ids: a sequence of revision-ids;
 
2577
          a revision-id may not be None or 'null:'
 
2578
        :param file_ids: if not None, the result is filtered
 
2579
          so that only those file-ids, their parents and their
 
2580
          children are included.
 
2581
        """
 
2582
        inventories = self.iter_inventories(revision_ids)
 
2583
        for inv in inventories:
 
2584
            # Should we introduce a FilteredRevisionTree class rather
 
2585
            # than pre-filter the inventory here?
 
2586
            filtered_inv = inv.filter(file_ids)
 
2587
            yield RevisionTree(self, filtered_inv, filtered_inv.revision_id)
589
2588
 
590
2589
    @needs_read_lock
591
 
    def get_ancestry(self, revision_id):
 
2590
    def get_ancestry(self, revision_id, topo_sorted=True):
592
2591
        """Return a list of revision-ids integrated by a revision.
593
2592
 
594
 
        The first element of the list is always None, indicating the origin 
595
 
        revision.  This might change when we have history horizons, or 
 
2593
        The first element of the list is always None, indicating the origin
 
2594
        revision.  This might change when we have history horizons, or
596
2595
        perhaps we should have a new API.
597
 
        
 
2596
 
598
2597
        This is topologically sorted.
599
2598
        """
600
 
        if revision_id is None:
 
2599
        if _mod_revision.is_null(revision_id):
601
2600
            return [None]
602
2601
        if not self.has_revision(revision_id):
603
2602
            raise errors.NoSuchRevision(self, revision_id)
604
 
        w = self.get_inventory_weave()
605
 
        candidates = w.get_ancestry(revision_id)
606
 
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
607
 
 
608
 
    @needs_read_lock
609
 
    def print_file(self, file, revision_id):
610
 
        """Print `file` to stdout.
611
 
        
612
 
        FIXME RBC 20060125 as John Meinel points out this is a bad api
613
 
        - it writes to stdout, it assumes that that is valid etc. Fix
614
 
        by creating a new more flexible convenience function.
 
2603
        graph = self.get_graph()
 
2604
        keys = set()
 
2605
        search = graph._make_breadth_first_searcher([revision_id])
 
2606
        while True:
 
2607
            try:
 
2608
                found, ghosts = search.next_with_ghosts()
 
2609
            except StopIteration:
 
2610
                break
 
2611
            keys.update(found)
 
2612
        if _mod_revision.NULL_REVISION in keys:
 
2613
            keys.remove(_mod_revision.NULL_REVISION)
 
2614
        if topo_sorted:
 
2615
            parent_map = graph.get_parent_map(keys)
 
2616
            keys = tsort.topo_sort(parent_map)
 
2617
        return [None] + list(keys)
 
2618
 
 
2619
    def pack(self, hint=None, clean_obsolete_packs=False):
 
2620
        """Compress the data within the repository.
 
2621
 
 
2622
        This operation only makes sense for some repository types. For other
 
2623
        types it should be a no-op that just returns.
 
2624
 
 
2625
        This stub method does not require a lock, but subclasses should use
 
2626
        @needs_write_lock as this is a long running call it's reasonable to
 
2627
        implicitly lock for the user.
 
2628
 
 
2629
        :param hint: If not supplied, the whole repository is packed.
 
2630
            If supplied, the repository may use the hint parameter as a
 
2631
            hint for the parts of the repository to pack. A hint can be
 
2632
            obtained from the result of commit_write_group(). Out of
 
2633
            date hints are simply ignored, because concurrent operations
 
2634
            can obsolete them rapidly.
 
2635
 
 
2636
        :param clean_obsolete_packs: Clean obsolete packs immediately after
 
2637
            the pack operation.
615
2638
        """
616
 
        tree = self.revision_tree(revision_id)
617
 
        # use inventory as it was in that revision
618
 
        file_id = tree.inventory.path2id(file)
619
 
        if not file_id:
620
 
            # TODO: jam 20060427 Write a test for this code path
621
 
            #       it had a bug in it, and was raising the wrong
622
 
            #       exception.
623
 
            raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
624
 
        tree.print_file(file_id)
625
2639
 
626
2640
    def get_transaction(self):
627
2641
        return self.control_files.get_transaction()
628
2642
 
629
 
    def revision_parents(self, revid):
630
 
        return self.get_inventory_weave().parent_names(revid)
 
2643
    def get_parent_map(self, revision_ids):
 
2644
        """See graph.StackedParentsProvider.get_parent_map"""
 
2645
        # revisions index works in keys; this just works in revisions
 
2646
        # therefore wrap and unwrap
 
2647
        query_keys = []
 
2648
        result = {}
 
2649
        for revision_id in revision_ids:
 
2650
            if revision_id == _mod_revision.NULL_REVISION:
 
2651
                result[revision_id] = ()
 
2652
            elif revision_id is None:
 
2653
                raise ValueError('get_parent_map(None) is not valid')
 
2654
            else:
 
2655
                query_keys.append((revision_id ,))
 
2656
        for ((revision_id,), parent_keys) in \
 
2657
                self.revisions.get_parent_map(query_keys).iteritems():
 
2658
            if parent_keys:
 
2659
                result[revision_id] = tuple([parent_revid
 
2660
                    for (parent_revid,) in parent_keys])
 
2661
            else:
 
2662
                result[revision_id] = (_mod_revision.NULL_REVISION,)
 
2663
        return result
 
2664
 
 
2665
    def _make_parents_provider(self):
 
2666
        return self
 
2667
 
 
2668
    @needs_read_lock
 
2669
    def get_known_graph_ancestry(self, revision_ids):
 
2670
        """Return the known graph for a set of revision ids and their ancestors.
 
2671
        """
 
2672
        st = static_tuple.StaticTuple
 
2673
        revision_keys = [st(r_id).intern() for r_id in revision_ids]
 
2674
        known_graph = self.revisions.get_known_graph_ancestry(revision_keys)
 
2675
        return graph.GraphThunkIdsToKeys(known_graph)
 
2676
 
 
2677
    def get_graph(self, other_repository=None):
 
2678
        """Return the graph walker for this repository format"""
 
2679
        parents_provider = self._make_parents_provider()
 
2680
        if (other_repository is not None and
 
2681
            not self.has_same_location(other_repository)):
 
2682
            parents_provider = graph.StackedParentsProvider(
 
2683
                [parents_provider, other_repository._make_parents_provider()])
 
2684
        return graph.Graph(parents_provider)
 
2685
 
 
2686
    def _get_versioned_file_checker(self, text_key_references=None,
 
2687
        ancestors=None):
 
2688
        """Return an object suitable for checking versioned files.
 
2689
        
 
2690
        :param text_key_references: if non-None, an already built
 
2691
            dictionary mapping text keys ((fileid, revision_id) tuples)
 
2692
            to whether they were referred to by the inventory of the
 
2693
            revision_id that they contain. If None, this will be
 
2694
            calculated.
 
2695
        :param ancestors: Optional result from
 
2696
            self.get_graph().get_parent_map(self.all_revision_ids()) if already
 
2697
            available.
 
2698
        """
 
2699
        return _VersionedFileChecker(self,
 
2700
            text_key_references=text_key_references, ancestors=ancestors)
 
2701
 
 
2702
    def revision_ids_to_search_result(self, result_set):
 
2703
        """Convert a set of revision ids to a graph SearchResult."""
 
2704
        result_parents = set()
 
2705
        for parents in self.get_graph().get_parent_map(
 
2706
            result_set).itervalues():
 
2707
            result_parents.update(parents)
 
2708
        included_keys = result_set.intersection(result_parents)
 
2709
        start_keys = result_set.difference(included_keys)
 
2710
        exclude_keys = result_parents.difference(result_set)
 
2711
        result = graph.SearchResult(start_keys, exclude_keys,
 
2712
            len(result_set), result_set)
 
2713
        return result
631
2714
 
632
2715
    @needs_write_lock
633
2716
    def set_make_working_trees(self, new_value):
640
2723
                          working trees.
641
2724
        """
642
2725
        raise NotImplementedError(self.set_make_working_trees)
643
 
    
 
2726
 
644
2727
    def make_working_trees(self):
645
2728
        """Returns the policy for making working trees on new branches."""
646
2729
        raise NotImplementedError(self.make_working_trees)
653
2736
    @needs_read_lock
654
2737
    def has_signature_for_revision_id(self, revision_id):
655
2738
        """Query for a revision signature for revision_id in the repository."""
656
 
        return self._revision_store.has_signature(revision_id,
657
 
                                                  self.get_transaction())
 
2739
        if not self.has_revision(revision_id):
 
2740
            raise errors.NoSuchRevision(self, revision_id)
 
2741
        sig_present = (1 == len(
 
2742
            self.signatures.get_parent_map([(revision_id,)])))
 
2743
        return sig_present
658
2744
 
659
2745
    @needs_read_lock
660
2746
    def get_signature_text(self, revision_id):
661
2747
        """Return the text for a signature."""
662
 
        return self._revision_store.get_signature_text(revision_id,
663
 
                                                       self.get_transaction())
 
2748
        stream = self.signatures.get_record_stream([(revision_id,)],
 
2749
            'unordered', True)
 
2750
        record = stream.next()
 
2751
        if record.storage_kind == 'absent':
 
2752
            raise errors.NoSuchRevision(self, revision_id)
 
2753
        return record.get_bytes_as('fulltext')
664
2754
 
665
2755
    @needs_read_lock
666
 
    def check(self, revision_ids):
 
2756
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
667
2757
        """Check consistency of all history of given revision_ids.
668
2758
 
669
2759
        Different repository implementations should override _check().
670
2760
 
671
2761
        :param revision_ids: A non-empty list of revision_ids whose ancestry
672
2762
             will be checked.  Typically the last revision_id of a branch.
 
2763
        :param callback_refs: A dict of check-refs to resolve and callback
 
2764
            the check/_check method on the items listed as wanting the ref.
 
2765
            see bzrlib.check.
 
2766
        :param check_repo: If False do not check the repository contents, just 
 
2767
            calculate the data callback_refs requires and call them back.
673
2768
        """
674
 
        if not revision_ids:
675
 
            raise ValueError("revision_ids must be non-empty in %s.check" 
676
 
                    % (self,))
677
 
        return self._check(revision_ids)
 
2769
        return self._check(revision_ids, callback_refs=callback_refs,
 
2770
            check_repo=check_repo)
678
2771
 
679
 
    def _check(self, revision_ids):
680
 
        result = check.Check(self)
681
 
        result.check()
 
2772
    def _check(self, revision_ids, callback_refs, check_repo):
 
2773
        result = check.Check(self, check_repo=check_repo)
 
2774
        result.check(callback_refs)
682
2775
        return result
683
2776
 
684
 
 
685
 
class AllInOneRepository(Repository):
686
 
    """Legacy support - the repository behaviour for all-in-one branches."""
687
 
 
688
 
    def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
689
 
        # we reuse one control files instance.
690
 
        dir_mode = a_bzrdir._control_files._dir_mode
691
 
        file_mode = a_bzrdir._control_files._file_mode
692
 
 
693
 
        def get_store(name, compressed=True, prefixed=False):
694
 
            # FIXME: This approach of assuming stores are all entirely compressed
695
 
            # or entirely uncompressed is tidy, but breaks upgrade from 
696
 
            # some existing branches where there's a mixture; we probably 
697
 
            # still want the option to look for both.
698
 
            relpath = a_bzrdir._control_files._escape(name)
699
 
            store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
700
 
                              prefixed=prefixed, compressed=compressed,
701
 
                              dir_mode=dir_mode,
702
 
                              file_mode=file_mode)
703
 
            #if self._transport.should_cache():
704
 
            #    cache_path = os.path.join(self.cache_root, name)
705
 
            #    os.mkdir(cache_path)
706
 
            #    store = bzrlib.store.CachedStore(store, cache_path)
707
 
            return store
708
 
 
709
 
        # not broken out yet because the controlweaves|inventory_store
710
 
        # and text_store | weave_store bits are still different.
711
 
        if isinstance(_format, RepositoryFormat4):
712
 
            # cannot remove these - there is still no consistent api 
713
 
            # which allows access to this old info.
714
 
            self.inventory_store = get_store('inventory-store')
715
 
            text_store = get_store('text-store')
716
 
        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
717
 
 
718
 
    @needs_read_lock
719
 
    def is_shared(self):
720
 
        """AllInOne repositories cannot be shared."""
721
 
        return False
722
 
 
723
 
    @needs_write_lock
724
 
    def set_make_working_trees(self, new_value):
725
 
        """Set the policy flag for making working trees when creating branches.
726
 
 
727
 
        This only applies to branches that use this repository.
728
 
 
729
 
        The default is 'True'.
730
 
        :param new_value: True to restore the default, False to disable making
731
 
                          working trees.
 
2777
    def _warn_if_deprecated(self, branch=None):
 
2778
        global _deprecation_warning_done
 
2779
        if _deprecation_warning_done:
 
2780
            return
 
2781
        try:
 
2782
            if branch is None:
 
2783
                conf = config.GlobalConfig()
 
2784
            else:
 
2785
                conf = branch.get_config()
 
2786
            if conf.suppress_warning('format_deprecation'):
 
2787
                return
 
2788
            warning("Format %s for %s is deprecated -"
 
2789
                    " please use 'bzr upgrade' to get better performance"
 
2790
                    % (self._format, self.bzrdir.transport.base))
 
2791
        finally:
 
2792
            _deprecation_warning_done = True
 
2793
 
 
2794
    def supports_rich_root(self):
 
2795
        return self._format.rich_root_data
 
2796
 
 
2797
    def _check_ascii_revisionid(self, revision_id, method):
 
2798
        """Private helper for ascii-only repositories."""
 
2799
        # weave repositories refuse to store revisionids that are non-ascii.
 
2800
        if revision_id is not None:
 
2801
            # weaves require ascii revision ids.
 
2802
            if isinstance(revision_id, unicode):
 
2803
                try:
 
2804
                    revision_id.encode('ascii')
 
2805
                except UnicodeEncodeError:
 
2806
                    raise errors.NonAsciiRevisionId(method, self)
 
2807
            else:
 
2808
                try:
 
2809
                    revision_id.decode('ascii')
 
2810
                except UnicodeDecodeError:
 
2811
                    raise errors.NonAsciiRevisionId(method, self)
 
2812
 
 
2813
    def revision_graph_can_have_wrong_parents(self):
 
2814
        """Is it possible for this repository to have a revision graph with
 
2815
        incorrect parents?
 
2816
 
 
2817
        If True, then this repository must also implement
 
2818
        _find_inconsistent_revision_parents so that check and reconcile can
 
2819
        check for inconsistencies before proceeding with other checks that may
 
2820
        depend on the revision index being consistent.
732
2821
        """
733
 
        raise NotImplementedError(self.set_make_working_trees)
734
 
    
735
 
    def make_working_trees(self):
736
 
        """Returns the policy for making working trees on new branches."""
737
 
        return True
 
2822
        raise NotImplementedError(self.revision_graph_can_have_wrong_parents)
 
2823
 
 
2824
 
 
2825
# remove these delegates a while after bzr 0.15
 
2826
def __make_delegated(name, from_module):
 
2827
    def _deprecated_repository_forwarder():
 
2828
        symbol_versioning.warn('%s moved to %s in bzr 0.15'
 
2829
            % (name, from_module),
 
2830
            DeprecationWarning,
 
2831
            stacklevel=2)
 
2832
        try:
 
2833
            return pyutils.get_named_object(from_module, name)
 
2834
        except AttributeError:
 
2835
            raise AttributeError('module %s has no name %s'
 
2836
                    % (sys.modules[from_module], name))
 
2837
    globals()[name] = _deprecated_repository_forwarder
 
2838
 
 
2839
for _name in [
 
2840
        'AllInOneRepository',
 
2841
        'WeaveMetaDirRepository',
 
2842
        'PreSplitOutRepositoryFormat',
 
2843
        'RepositoryFormat4',
 
2844
        'RepositoryFormat5',
 
2845
        'RepositoryFormat6',
 
2846
        'RepositoryFormat7',
 
2847
        ]:
 
2848
    __make_delegated(_name, 'bzrlib.repofmt.weaverepo')
 
2849
 
 
2850
for _name in [
 
2851
        'KnitRepository',
 
2852
        'RepositoryFormatKnit',
 
2853
        'RepositoryFormatKnit1',
 
2854
        ]:
 
2855
    __make_delegated(_name, 'bzrlib.repofmt.knitrepo')
738
2856
 
739
2857
 
740
2858
def install_revision(repository, rev, revision_tree):
741
2859
    """Install all revision data into a repository."""
 
2860
    install_revisions(repository, [(rev, revision_tree, None)])
 
2861
 
 
2862
 
 
2863
def install_revisions(repository, iterable, num_revisions=None, pb=None):
 
2864
    """Install all revision data into a repository.
 
2865
 
 
2866
    Accepts an iterable of revision, tree, signature tuples.  The signature
 
2867
    may be None.
 
2868
    """
 
2869
    repository.start_write_group()
 
2870
    try:
 
2871
        inventory_cache = lru_cache.LRUCache(10)
 
2872
        for n, (revision, revision_tree, signature) in enumerate(iterable):
 
2873
            _install_revision(repository, revision, revision_tree, signature,
 
2874
                inventory_cache)
 
2875
            if pb is not None:
 
2876
                pb.update('Transferring revisions', n + 1, num_revisions)
 
2877
    except:
 
2878
        repository.abort_write_group()
 
2879
        raise
 
2880
    else:
 
2881
        repository.commit_write_group()
 
2882
 
 
2883
 
 
2884
def _install_revision(repository, rev, revision_tree, signature,
 
2885
    inventory_cache):
 
2886
    """Install all revision data into a repository."""
742
2887
    present_parents = []
743
2888
    parent_trees = {}
744
2889
    for p_id in rev.parent_ids:
746
2891
            present_parents.append(p_id)
747
2892
            parent_trees[p_id] = repository.revision_tree(p_id)
748
2893
        else:
749
 
            parent_trees[p_id] = EmptyTree()
 
2894
            parent_trees[p_id] = repository.revision_tree(
 
2895
                                     _mod_revision.NULL_REVISION)
750
2896
 
751
2897
    inv = revision_tree.inventory
752
 
    
 
2898
    entries = inv.iter_entries()
 
2899
    # backwards compatibility hack: skip the root id.
 
2900
    if not repository.supports_rich_root():
 
2901
        path, root = entries.next()
 
2902
        if root.revision != rev.revision_id:
 
2903
            raise errors.IncompatibleRevision(repr(repository))
 
2904
    text_keys = {}
 
2905
    for path, ie in entries:
 
2906
        text_keys[(ie.file_id, ie.revision)] = ie
 
2907
    text_parent_map = repository.texts.get_parent_map(text_keys)
 
2908
    missing_texts = set(text_keys) - set(text_parent_map)
753
2909
    # Add the texts that are not already present
754
 
    for path, ie in inv.iter_entries():
755
 
        w = repository.weave_store.get_weave_or_empty(ie.file_id,
756
 
                repository.get_transaction())
757
 
        if ie.revision not in w:
758
 
            text_parents = []
759
 
            # FIXME: TODO: The following loop *may* be overlapping/duplicate
760
 
            # with InventoryEntry.find_previous_heads(). if it is, then there
761
 
            # is a latent bug here where the parents may have ancestors of each
762
 
            # other. RBC, AB
763
 
            for revision, tree in parent_trees.iteritems():
764
 
                if ie.file_id not in tree:
765
 
                    continue
766
 
                parent_id = tree.inventory[ie.file_id].revision
767
 
                if parent_id in text_parents:
768
 
                    continue
769
 
                text_parents.append(parent_id)
770
 
                    
771
 
            vfile = repository.weave_store.get_weave_or_empty(ie.file_id, 
772
 
                repository.get_transaction())
773
 
            lines = revision_tree.get_file(ie.file_id).readlines()
774
 
            vfile.add_lines(rev.revision_id, text_parents, lines)
 
2910
    for text_key in missing_texts:
 
2911
        ie = text_keys[text_key]
 
2912
        text_parents = []
 
2913
        # FIXME: TODO: The following loop overlaps/duplicates that done by
 
2914
        # commit to determine parents. There is a latent/real bug here where
 
2915
        # the parents inserted are not those commit would do - in particular
 
2916
        # they are not filtered by heads(). RBC, AB
 
2917
        for revision, tree in parent_trees.iteritems():
 
2918
            if ie.file_id not in tree:
 
2919
                continue
 
2920
            parent_id = tree.inventory[ie.file_id].revision
 
2921
            if parent_id in text_parents:
 
2922
                continue
 
2923
            text_parents.append((ie.file_id, parent_id))
 
2924
        lines = revision_tree.get_file(ie.file_id).readlines()
 
2925
        repository.texts.add_lines(text_key, text_parents, lines)
775
2926
    try:
776
2927
        # install the inventory
777
 
        repository.add_inventory(rev.revision_id, inv, present_parents)
 
2928
        if repository._format._commit_inv_deltas and len(rev.parent_ids):
 
2929
            # Cache this inventory
 
2930
            inventory_cache[rev.revision_id] = inv
 
2931
            try:
 
2932
                basis_inv = inventory_cache[rev.parent_ids[0]]
 
2933
            except KeyError:
 
2934
                repository.add_inventory(rev.revision_id, inv, present_parents)
 
2935
            else:
 
2936
                delta = inv._make_delta(basis_inv)
 
2937
                repository.add_inventory_by_delta(rev.parent_ids[0], delta,
 
2938
                    rev.revision_id, present_parents)
 
2939
        else:
 
2940
            repository.add_inventory(rev.revision_id, inv, present_parents)
778
2941
    except errors.RevisionAlreadyPresent:
779
2942
        pass
 
2943
    if signature is not None:
 
2944
        repository.add_signature_text(rev.revision_id, signature)
780
2945
    repository.add_revision(rev.revision_id, rev, inv)
781
2946
 
782
2947
 
783
2948
class MetaDirRepository(Repository):
784
 
    """Repositories in the new meta-dir layout."""
785
 
 
786
 
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
787
 
        super(MetaDirRepository, self).__init__(_format,
788
 
                                                a_bzrdir,
789
 
                                                control_files,
790
 
                                                _revision_store,
791
 
                                                control_store,
792
 
                                                text_store)
793
 
 
794
 
        dir_mode = self.control_files._dir_mode
795
 
        file_mode = self.control_files._file_mode
796
 
 
797
 
    @needs_read_lock
 
2949
    """Repositories in the new meta-dir layout.
 
2950
 
 
2951
    :ivar _transport: Transport for access to repository control files,
 
2952
        typically pointing to .bzr/repository.
 
2953
    """
 
2954
 
 
2955
    def __init__(self, _format, a_bzrdir, control_files):
 
2956
        super(MetaDirRepository, self).__init__(_format, a_bzrdir, control_files)
 
2957
        self._transport = control_files._transport
 
2958
 
798
2959
    def is_shared(self):
799
2960
        """Return True if this repository is flagged as a shared repository."""
800
 
        return self.control_files._transport.has('shared-storage')
 
2961
        return self._transport.has('shared-storage')
801
2962
 
802
2963
    @needs_write_lock
803
2964
    def set_make_working_trees(self, new_value):
811
2972
        """
812
2973
        if new_value:
813
2974
            try:
814
 
                self.control_files._transport.delete('no-working-trees')
 
2975
                self._transport.delete('no-working-trees')
815
2976
            except errors.NoSuchFile:
816
2977
                pass
817
2978
        else:
818
 
            self.control_files.put_utf8('no-working-trees', '')
819
 
    
 
2979
            self._transport.put_bytes('no-working-trees', '',
 
2980
                mode=self.bzrdir._get_file_mode())
 
2981
 
820
2982
    def make_working_trees(self):
821
2983
        """Returns the policy for making working trees on new branches."""
822
 
        return not self.control_files._transport.has('no-working-trees')
823
 
 
824
 
 
825
 
class KnitRepository(MetaDirRepository):
826
 
    """Knit format repository."""
827
 
 
828
 
    def _inventory_add_lines(self, inv_vf, revid, parents, lines):
829
 
        inv_vf.add_lines_with_ghosts(revid, parents, lines)
830
 
 
831
 
    @needs_read_lock
832
 
    def _all_revision_ids(self):
833
 
        """See Repository.all_revision_ids()."""
834
 
        # Knits get the revision graph from the index of the revision knit, so
835
 
        # it's always possible even if they're on an unlistable transport.
836
 
        return self._revision_store.all_revision_ids(self.get_transaction())
837
 
 
838
 
    def fileid_involved_between_revs(self, from_revid, to_revid):
839
 
        """Find file_id(s) which are involved in the changes between revisions.
840
 
 
841
 
        This determines the set of revisions which are involved, and then
842
 
        finds all file ids affected by those revisions.
843
 
        """
844
 
        vf = self._get_revision_vf()
845
 
        from_set = set(vf.get_ancestry(from_revid))
846
 
        to_set = set(vf.get_ancestry(to_revid))
847
 
        changed = to_set.difference(from_set)
848
 
        return self._fileid_involved_by_set(changed)
849
 
 
850
 
    def fileid_involved(self, last_revid=None):
851
 
        """Find all file_ids modified in the ancestry of last_revid.
852
 
 
853
 
        :param last_revid: If None, last_revision() will be used.
854
 
        """
855
 
        if not last_revid:
856
 
            changed = set(self.all_revision_ids())
857
 
        else:
858
 
            changed = set(self.get_ancestry(last_revid))
859
 
        if None in changed:
860
 
            changed.remove(None)
861
 
        return self._fileid_involved_by_set(changed)
862
 
 
863
 
    @needs_read_lock
864
 
    def get_ancestry(self, revision_id):
865
 
        """Return a list of revision-ids integrated by a revision.
866
 
        
867
 
        This is topologically sorted.
868
 
        """
869
 
        if revision_id is None:
870
 
            return [None]
871
 
        vf = self._get_revision_vf()
872
 
        try:
873
 
            return [None] + vf.get_ancestry(revision_id)
874
 
        except errors.RevisionNotPresent:
875
 
            raise errors.NoSuchRevision(self, revision_id)
876
 
 
877
 
    @needs_read_lock
878
 
    def get_revision(self, revision_id):
879
 
        """Return the Revision object for a named revision"""
880
 
        return self.get_revision_reconcile(revision_id)
881
 
 
882
 
    @needs_read_lock
883
 
    def get_revision_graph(self, revision_id=None):
884
 
        """Return a dictionary containing the revision graph.
885
 
 
886
 
        :param revision_id: The revision_id to get a graph from. If None, then
887
 
        the entire revision graph is returned. This is a deprecated mode of
888
 
        operation and will be removed in the future.
889
 
        :return: a dictionary of revision_id->revision_parents_list.
890
 
        """
891
 
        # special case NULL_REVISION
892
 
        if revision_id == NULL_REVISION:
893
 
            return {}
894
 
        weave = self._get_revision_vf()
895
 
        entire_graph = weave.get_graph()
896
 
        if revision_id is None:
897
 
            return weave.get_graph()
898
 
        elif revision_id not in weave:
899
 
            raise errors.NoSuchRevision(self, revision_id)
900
 
        else:
901
 
            # add what can be reached from revision_id
902
 
            result = {}
903
 
            pending = set([revision_id])
904
 
            while len(pending) > 0:
905
 
                node = pending.pop()
906
 
                result[node] = weave.get_parents(node)
907
 
                for revision_id in result[node]:
908
 
                    if revision_id not in result:
909
 
                        pending.add(revision_id)
910
 
            return result
911
 
 
912
 
    @needs_read_lock
913
 
    def get_revision_graph_with_ghosts(self, revision_ids=None):
914
 
        """Return a graph of the revisions with ghosts marked as applicable.
915
 
 
916
 
        :param revision_ids: an iterable of revisions to graph or None for all.
917
 
        :return: a Graph object with the graph reachable from revision_ids.
918
 
        """
919
 
        result = Graph()
920
 
        vf = self._get_revision_vf()
921
 
        versions = set(vf.versions())
922
 
        if not revision_ids:
923
 
            pending = set(self.all_revision_ids())
924
 
            required = set([])
925
 
        else:
926
 
            pending = set(revision_ids)
927
 
            # special case NULL_REVISION
928
 
            if NULL_REVISION in pending:
929
 
                pending.remove(NULL_REVISION)
930
 
            required = set(pending)
931
 
        done = set([])
932
 
        while len(pending):
933
 
            revision_id = pending.pop()
934
 
            if not revision_id in versions:
935
 
                if revision_id in required:
936
 
                    raise errors.NoSuchRevision(self, revision_id)
937
 
                # a ghost
938
 
                result.add_ghost(revision_id)
939
 
                # mark it as done so we don't try for it again.
940
 
                done.add(revision_id)
941
 
                continue
942
 
            parent_ids = vf.get_parents_with_ghosts(revision_id)
943
 
            for parent_id in parent_ids:
944
 
                # is this queued or done ?
945
 
                if (parent_id not in pending and
946
 
                    parent_id not in done):
947
 
                    # no, queue it.
948
 
                    pending.add(parent_id)
949
 
            result.add_node(revision_id, parent_ids)
950
 
            done.add(revision_id)
951
 
        return result
952
 
 
953
 
    def _get_revision_vf(self):
954
 
        """:return: a versioned file containing the revisions."""
955
 
        vf = self._revision_store.get_revision_file(self.get_transaction())
956
 
        return vf
957
 
 
958
 
    @needs_write_lock
959
 
    def reconcile(self, other=None, thorough=False):
960
 
        """Reconcile this repository."""
961
 
        from bzrlib.reconcile import KnitReconciler
962
 
        reconciler = KnitReconciler(self, thorough=thorough)
963
 
        reconciler.reconcile()
964
 
        return reconciler
965
 
    
966
 
    def revision_parents(self, revision_id):
967
 
        return self._get_revision_vf().get_parents(revision_id)
968
 
 
 
2984
        return not self._transport.has('no-working-trees')
 
2985
 
 
2986
 
 
2987
class MetaDirVersionedFileRepository(MetaDirRepository):
 
2988
    """Repositories in a meta-dir, that work via versioned file objects."""
 
2989
 
 
2990
    def __init__(self, _format, a_bzrdir, control_files):
 
2991
        super(MetaDirVersionedFileRepository, self).__init__(_format, a_bzrdir,
 
2992
            control_files)
 
2993
 
 
2994
 
 
2995
network_format_registry = registry.FormatRegistry()
 
2996
"""Registry of formats indexed by their network name.
 
2997
 
 
2998
The network name for a repository format is an identifier that can be used when
 
2999
referring to formats with smart server operations. See
 
3000
RepositoryFormat.network_name() for more detail.
 
3001
"""
 
3002
 
 
3003
 
 
3004
format_registry = registry.FormatRegistry(network_format_registry)
 
3005
"""Registry of formats, indexed by their BzrDirMetaFormat format string.
 
3006
 
 
3007
This can contain either format instances themselves, or classes/factories that
 
3008
can be called to obtain one.
 
3009
"""
 
3010
 
 
3011
 
 
3012
#####################################################################
 
3013
# Repository Formats
969
3014
 
970
3015
class RepositoryFormat(object):
971
3016
    """A repository format.
972
3017
 
973
 
    Formats provide three things:
 
3018
    Formats provide four things:
974
3019
     * An initialization routine to construct repository data on disk.
975
 
     * a format string which is used when the BzrDir supports versioned
976
 
       children.
 
3020
     * a optional format string which is used when the BzrDir supports
 
3021
       versioned children.
977
3022
     * an open routine which returns a Repository instance.
978
 
 
979
 
    Formats are placed in an dict by their format string for reference 
980
 
    during opening. These should be subclasses of RepositoryFormat
981
 
    for consistency.
 
3023
     * A network name for referring to the format in smart server RPC
 
3024
       methods.
 
3025
 
 
3026
    There is one and only one Format subclass for each on-disk format. But
 
3027
    there can be one Repository subclass that is used for several different
 
3028
    formats. The _format attribute on a Repository instance can be used to
 
3029
    determine the disk format.
 
3030
 
 
3031
    Formats are placed in a registry by their format string for reference
 
3032
    during opening. These should be subclasses of RepositoryFormat for
 
3033
    consistency.
982
3034
 
983
3035
    Once a format is deprecated, just deprecate the initialize and open
984
 
    methods on the format class. Do not deprecate the object, as the 
985
 
    object will be created every system load.
 
3036
    methods on the format class. Do not deprecate the object, as the
 
3037
    object may be created even when a repository instance hasn't been
 
3038
    created.
986
3039
 
987
3040
    Common instance attributes:
988
3041
    _matchingbzrdir - the bzrdir format that the repository format was
989
3042
    originally written to work with. This can be used if manually
990
3043
    constructing a bzrdir and repository, or more commonly for test suite
991
 
    parameterisation.
 
3044
    parameterization.
992
3045
    """
993
3046
 
994
 
    _default_format = None
995
 
    """The default format used for new repositories."""
996
 
 
997
 
    _formats = {}
998
 
    """The known formats."""
 
3047
    # Set to True or False in derived classes. True indicates that the format
 
3048
    # supports ghosts gracefully.
 
3049
    supports_ghosts = None
 
3050
    # Can this repository be given external locations to lookup additional
 
3051
    # data. Set to True or False in derived classes.
 
3052
    supports_external_lookups = None
 
3053
    # Does this format support CHK bytestring lookups. Set to True or False in
 
3054
    # derived classes.
 
3055
    supports_chks = None
 
3056
    # Should commit add an inventory, or an inventory delta to the repository.
 
3057
    _commit_inv_deltas = True
 
3058
    # What order should fetch operations request streams in?
 
3059
    # The default is unordered as that is the cheapest for an origin to
 
3060
    # provide.
 
3061
    _fetch_order = 'unordered'
 
3062
    # Does this repository format use deltas that can be fetched as-deltas ?
 
3063
    # (E.g. knits, where the knit deltas can be transplanted intact.
 
3064
    # We default to False, which will ensure that enough data to get
 
3065
    # a full text out of any fetch stream will be grabbed.
 
3066
    _fetch_uses_deltas = False
 
3067
    # Should fetch trigger a reconcile after the fetch? Only needed for
 
3068
    # some repository formats that can suffer internal inconsistencies.
 
3069
    _fetch_reconcile = False
 
3070
    # Does this format have < O(tree_size) delta generation. Used to hint what
 
3071
    # code path for commit, amongst other things.
 
3072
    fast_deltas = None
 
3073
    # Does doing a pack operation compress data? Useful for the pack UI command
 
3074
    # (so if there is one pack, the operation can still proceed because it may
 
3075
    # help), and for fetching when data won't have come from the same
 
3076
    # compressor.
 
3077
    pack_compresses = False
 
3078
    # Does the repository inventory storage understand references to trees?
 
3079
    supports_tree_reference = None
 
3080
    # Is the format experimental ?
 
3081
    experimental = False
 
3082
 
 
3083
    def __repr__(self):
 
3084
        return "%s()" % self.__class__.__name__
 
3085
 
 
3086
    def __eq__(self, other):
 
3087
        # format objects are generally stateless
 
3088
        return isinstance(other, self.__class__)
 
3089
 
 
3090
    def __ne__(self, other):
 
3091
        return not self == other
999
3092
 
1000
3093
    @classmethod
1001
3094
    def find_format(klass, a_bzrdir):
1002
 
        """Return the format for the repository object in a_bzrdir."""
 
3095
        """Return the format for the repository object in a_bzrdir.
 
3096
 
 
3097
        This is used by bzr native formats that have a "format" file in
 
3098
        the repository.  Other methods may be used by different types of
 
3099
        control directory.
 
3100
        """
1003
3101
        try:
1004
3102
            transport = a_bzrdir.get_repository_transport(None)
1005
 
            format_string = transport.get("format").read()
1006
 
            return klass._formats[format_string]
 
3103
            format_string = transport.get_bytes("format")
 
3104
            return format_registry.get(format_string)
1007
3105
        except errors.NoSuchFile:
1008
3106
            raise errors.NoRepositoryPresent(a_bzrdir)
1009
3107
        except KeyError:
1010
 
            raise errors.UnknownFormatError(format=format_string)
1011
 
 
1012
 
    def _get_control_store(self, repo_transport, control_files):
1013
 
        """Return the control store for this repository."""
1014
 
        raise NotImplementedError(self._get_control_store)
1015
 
    
 
3108
            raise errors.UnknownFormatError(format=format_string,
 
3109
                                            kind='repository')
 
3110
 
 
3111
    @classmethod
 
3112
    def register_format(klass, format):
 
3113
        format_registry.register(format.get_format_string(), format)
 
3114
 
 
3115
    @classmethod
 
3116
    def unregister_format(klass, format):
 
3117
        format_registry.remove(format.get_format_string())
 
3118
 
1016
3119
    @classmethod
1017
3120
    def get_default_format(klass):
1018
3121
        """Return the current default format."""
1019
 
        return klass._default_format
 
3122
        from bzrlib import bzrdir
 
3123
        return bzrdir.format_registry.make_bzrdir('default').repository_format
1020
3124
 
1021
3125
    def get_format_string(self):
1022
3126
        """Return the ASCII format string that identifies this format.
1023
 
        
1024
 
        Note that in pre format ?? repositories the format string is 
 
3127
 
 
3128
        Note that in pre format ?? repositories the format string is
1025
3129
        not permitted nor written to disk.
1026
3130
        """
1027
3131
        raise NotImplementedError(self.get_format_string)
1030
3134
        """Return the short description for this format."""
1031
3135
        raise NotImplementedError(self.get_format_description)
1032
3136
 
1033
 
    def _get_revision_store(self, repo_transport, control_files):
1034
 
        """Return the revision store object for this a_bzrdir."""
1035
 
        raise NotImplementedError(self._get_revision_store)
1036
 
 
1037
 
    def _get_text_rev_store(self,
1038
 
                            transport,
1039
 
                            control_files,
1040
 
                            name,
1041
 
                            compressed=True,
1042
 
                            prefixed=False,
1043
 
                            serializer=None):
1044
 
        """Common logic for getting a revision store for a repository.
1045
 
        
1046
 
        see self._get_revision_store for the subclass-overridable method to 
1047
 
        get the store for a repository.
1048
 
        """
1049
 
        from bzrlib.store.revision.text import TextRevisionStore
1050
 
        dir_mode = control_files._dir_mode
1051
 
        file_mode = control_files._file_mode
1052
 
        text_store =TextStore(transport.clone(name),
1053
 
                              prefixed=prefixed,
1054
 
                              compressed=compressed,
1055
 
                              dir_mode=dir_mode,
1056
 
                              file_mode=file_mode)
1057
 
        _revision_store = TextRevisionStore(text_store, serializer)
1058
 
        return _revision_store
1059
 
 
 
3137
    # TODO: this shouldn't be in the base class, it's specific to things that
 
3138
    # use weaves or knits -- mbp 20070207
1060
3139
    def _get_versioned_file_store(self,
1061
3140
                                  name,
1062
3141
                                  transport,
1063
3142
                                  control_files,
1064
3143
                                  prefixed=True,
1065
 
                                  versionedfile_class=WeaveFile,
 
3144
                                  versionedfile_class=None,
 
3145
                                  versionedfile_kwargs={},
1066
3146
                                  escaped=False):
 
3147
        if versionedfile_class is None:
 
3148
            versionedfile_class = self._versionedfile_class
1067
3149
        weave_transport = control_files._transport.clone(name)
1068
3150
        dir_mode = control_files._dir_mode
1069
3151
        file_mode = control_files._file_mode
1071
3153
                                  dir_mode=dir_mode,
1072
3154
                                  file_mode=file_mode,
1073
3155
                                  versionedfile_class=versionedfile_class,
 
3156
                                  versionedfile_kwargs=versionedfile_kwargs,
1074
3157
                                  escaped=escaped)
1075
3158
 
1076
3159
    def initialize(self, a_bzrdir, shared=False):
1078
3161
 
1079
3162
        :param a_bzrdir: The bzrdir to put the new repository in it.
1080
3163
        :param shared: The repository should be initialized as a sharable one.
 
3164
        :returns: The new repository object.
1081
3165
 
1082
3166
        This may raise UninitializableFormat if shared repository are not
1083
3167
        compatible the a_bzrdir.
1084
3168
        """
 
3169
        raise NotImplementedError(self.initialize)
1085
3170
 
1086
3171
    def is_supported(self):
1087
3172
        """Is this format supported?
1088
3173
 
1089
3174
        Supported formats must be initializable and openable.
1090
 
        Unsupported formats may not support initialization or committing or 
 
3175
        Unsupported formats may not support initialization or committing or
1091
3176
        some other features depending on the reason for not being supported.
1092
3177
        """
1093
3178
        return True
1094
3179
 
 
3180
    def network_name(self):
 
3181
        """A simple byte string uniquely identifying this format for RPC calls.
 
3182
 
 
3183
        MetaDir repository formats use their disk format string to identify the
 
3184
        repository over the wire. All in one formats such as bzr < 0.8, and
 
3185
        foreign formats like svn/git and hg should use some marker which is
 
3186
        unique and immutable.
 
3187
        """
 
3188
        raise NotImplementedError(self.network_name)
 
3189
 
 
3190
    def check_conversion_target(self, target_format):
 
3191
        if self.rich_root_data and not target_format.rich_root_data:
 
3192
            raise errors.BadConversionTarget(
 
3193
                'Does not support rich root data.', target_format,
 
3194
                from_format=self)
 
3195
        if (self.supports_tree_reference and 
 
3196
            not getattr(target_format, 'supports_tree_reference', False)):
 
3197
            raise errors.BadConversionTarget(
 
3198
                'Does not support nested trees', target_format,
 
3199
                from_format=self)
 
3200
 
1095
3201
    def open(self, a_bzrdir, _found=False):
1096
3202
        """Return an instance of this format for the bzrdir a_bzrdir.
1097
 
        
 
3203
 
1098
3204
        _found is a private parameter, do not use it.
1099
3205
        """
1100
3206
        raise NotImplementedError(self.open)
1101
3207
 
1102
 
    @classmethod
1103
 
    def register_format(klass, format):
1104
 
        klass._formats[format.get_format_string()] = format
1105
 
 
1106
 
    @classmethod
1107
 
    def set_default_format(klass, format):
1108
 
        klass._default_format = format
1109
 
 
1110
 
    @classmethod
1111
 
    def unregister_format(klass, format):
1112
 
        assert klass._formats[format.get_format_string()] is format
1113
 
        del klass._formats[format.get_format_string()]
1114
 
 
1115
 
 
1116
 
class PreSplitOutRepositoryFormat(RepositoryFormat):
1117
 
    """Base class for the pre split out repository formats."""
1118
 
 
1119
 
    def initialize(self, a_bzrdir, shared=False, _internal=False):
1120
 
        """Create a weave repository.
1121
 
        
1122
 
        TODO: when creating split out bzr branch formats, move this to a common
1123
 
        base for Format5, Format6. or something like that.
1124
 
        """
1125
 
        from bzrlib.weavefile import write_weave_v5
1126
 
        from bzrlib.weave import Weave
1127
 
 
1128
 
        if shared:
1129
 
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
1130
 
 
1131
 
        if not _internal:
1132
 
            # always initialized when the bzrdir is.
1133
 
            return self.open(a_bzrdir, _found=True)
1134
 
        
1135
 
        # Create an empty weave
1136
 
        sio = StringIO()
1137
 
        write_weave_v5(Weave(), sio)
1138
 
        empty_weave = sio.getvalue()
1139
 
 
1140
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
1141
 
        dirs = ['revision-store', 'weaves']
1142
 
        files = [('inventory.weave', StringIO(empty_weave)),
1143
 
                 ]
1144
 
        
1145
 
        # FIXME: RBC 20060125 don't peek under the covers
1146
 
        # NB: no need to escape relative paths that are url safe.
1147
 
        control_files = LockableFiles(a_bzrdir.transport, 'branch-lock',
1148
 
                                      TransportLock)
1149
 
        control_files.create_lock()
1150
 
        control_files.lock_write()
1151
 
        control_files._transport.mkdir_multi(dirs,
1152
 
                mode=control_files._dir_mode)
1153
 
        try:
1154
 
            for file, content in files:
1155
 
                control_files.put(file, content)
1156
 
        finally:
1157
 
            control_files.unlock()
1158
 
        return self.open(a_bzrdir, _found=True)
1159
 
 
1160
 
    def _get_control_store(self, repo_transport, control_files):
1161
 
        """Return the control store for this repository."""
1162
 
        return self._get_versioned_file_store('',
1163
 
                                              repo_transport,
1164
 
                                              control_files,
1165
 
                                              prefixed=False)
1166
 
 
1167
 
    def _get_text_store(self, transport, control_files):
1168
 
        """Get a store for file texts for this format."""
1169
 
        raise NotImplementedError(self._get_text_store)
1170
 
 
1171
 
    def open(self, a_bzrdir, _found=False):
1172
 
        """See RepositoryFormat.open()."""
1173
 
        if not _found:
1174
 
            # we are being called directly and must probe.
1175
 
            raise NotImplementedError
1176
 
 
1177
 
        repo_transport = a_bzrdir.get_repository_transport(None)
1178
 
        control_files = a_bzrdir._control_files
1179
 
        text_store = self._get_text_store(repo_transport, control_files)
1180
 
        control_store = self._get_control_store(repo_transport, control_files)
1181
 
        _revision_store = self._get_revision_store(repo_transport, control_files)
1182
 
        return AllInOneRepository(_format=self,
1183
 
                                  a_bzrdir=a_bzrdir,
1184
 
                                  _revision_store=_revision_store,
1185
 
                                  control_store=control_store,
1186
 
                                  text_store=text_store)
1187
 
 
1188
 
 
1189
 
class RepositoryFormat4(PreSplitOutRepositoryFormat):
1190
 
    """Bzr repository format 4.
1191
 
 
1192
 
    This repository format has:
1193
 
     - flat stores
1194
 
     - TextStores for texts, inventories,revisions.
1195
 
 
1196
 
    This format is deprecated: it indexes texts using a text id which is
1197
 
    removed in format 5; initialization and write support for this format
1198
 
    has been removed.
1199
 
    """
1200
 
 
1201
 
    def __init__(self):
1202
 
        super(RepositoryFormat4, self).__init__()
1203
 
        self._matchingbzrdir = bzrdir.BzrDirFormat4()
1204
 
 
1205
 
    def get_format_description(self):
1206
 
        """See RepositoryFormat.get_format_description()."""
1207
 
        return "Repository format 4"
1208
 
 
1209
 
    def initialize(self, url, shared=False, _internal=False):
1210
 
        """Format 4 branches cannot be created."""
1211
 
        raise errors.UninitializableFormat(self)
1212
 
 
1213
 
    def is_supported(self):
1214
 
        """Format 4 is not supported.
1215
 
 
1216
 
        It is not supported because the model changed from 4 to 5 and the
1217
 
        conversion logic is expensive - so doing it on the fly was not 
1218
 
        feasible.
1219
 
        """
1220
 
        return False
1221
 
 
1222
 
    def _get_control_store(self, repo_transport, control_files):
1223
 
        """Format 4 repositories have no formal control store at this point.
1224
 
        
1225
 
        This will cause any control-file-needing apis to fail - this is desired.
1226
 
        """
1227
 
        return None
1228
 
    
1229
 
    def _get_revision_store(self, repo_transport, control_files):
1230
 
        """See RepositoryFormat._get_revision_store()."""
1231
 
        from bzrlib.xml4 import serializer_v4
1232
 
        return self._get_text_rev_store(repo_transport,
1233
 
                                        control_files,
1234
 
                                        'revision-store',
1235
 
                                        serializer=serializer_v4)
1236
 
 
1237
 
    def _get_text_store(self, transport, control_files):
1238
 
        """See RepositoryFormat._get_text_store()."""
1239
 
 
1240
 
 
1241
 
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1242
 
    """Bzr control format 5.
1243
 
 
1244
 
    This repository format has:
1245
 
     - weaves for file texts and inventory
1246
 
     - flat stores
1247
 
     - TextStores for revisions and signatures.
1248
 
    """
1249
 
 
1250
 
    def __init__(self):
1251
 
        super(RepositoryFormat5, self).__init__()
1252
 
        self._matchingbzrdir = bzrdir.BzrDirFormat5()
1253
 
 
1254
 
    def get_format_description(self):
1255
 
        """See RepositoryFormat.get_format_description()."""
1256
 
        return "Weave repository format 5"
1257
 
 
1258
 
    def _get_revision_store(self, repo_transport, control_files):
1259
 
        """See RepositoryFormat._get_revision_store()."""
1260
 
        """Return the revision store object for this a_bzrdir."""
1261
 
        return self._get_text_rev_store(repo_transport,
1262
 
                                        control_files,
1263
 
                                        'revision-store',
1264
 
                                        compressed=False)
1265
 
 
1266
 
    def _get_text_store(self, transport, control_files):
1267
 
        """See RepositoryFormat._get_text_store()."""
1268
 
        return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
1269
 
 
1270
 
 
1271
 
class RepositoryFormat6(PreSplitOutRepositoryFormat):
1272
 
    """Bzr control format 6.
1273
 
 
1274
 
    This repository format has:
1275
 
     - weaves for file texts and inventory
1276
 
     - hash subdirectory based stores.
1277
 
     - TextStores for revisions and signatures.
1278
 
    """
1279
 
 
1280
 
    def __init__(self):
1281
 
        super(RepositoryFormat6, self).__init__()
1282
 
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
1283
 
 
1284
 
    def get_format_description(self):
1285
 
        """See RepositoryFormat.get_format_description()."""
1286
 
        return "Weave repository format 6"
1287
 
 
1288
 
    def _get_revision_store(self, repo_transport, control_files):
1289
 
        """See RepositoryFormat._get_revision_store()."""
1290
 
        return self._get_text_rev_store(repo_transport,
1291
 
                                        control_files,
1292
 
                                        'revision-store',
1293
 
                                        compressed=False,
1294
 
                                        prefixed=True)
1295
 
 
1296
 
    def _get_text_store(self, transport, control_files):
1297
 
        """See RepositoryFormat._get_text_store()."""
1298
 
        return self._get_versioned_file_store('weaves', transport, control_files)
 
3208
    def _run_post_repo_init_hooks(self, repository, a_bzrdir, shared):
 
3209
        from bzrlib.bzrdir import BzrDir, RepoInitHookParams
 
3210
        hooks = BzrDir.hooks['post_repo_init']
 
3211
        if not hooks:
 
3212
            return
 
3213
        params = RepoInitHookParams(repository, self, a_bzrdir, shared)
 
3214
        for hook in hooks:
 
3215
            hook(params)
1299
3216
 
1300
3217
 
1301
3218
class MetaDirRepositoryFormat(RepositoryFormat):
1302
3219
    """Common base class for the new repositories using the metadir layout."""
1303
3220
 
 
3221
    rich_root_data = False
 
3222
    supports_tree_reference = False
 
3223
    supports_external_lookups = False
 
3224
 
 
3225
    @property
 
3226
    def _matchingbzrdir(self):
 
3227
        matching = bzrdir.BzrDirMetaFormat1()
 
3228
        matching.repository_format = self
 
3229
        return matching
 
3230
 
1304
3231
    def __init__(self):
1305
3232
        super(MetaDirRepositoryFormat, self).__init__()
1306
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1307
3233
 
1308
3234
    def _create_control_files(self, a_bzrdir):
1309
3235
        """Create the required files and the initial control_files object."""
1310
3236
        # FIXME: RBC 20060125 don't peek under the covers
1311
3237
        # NB: no need to escape relative paths that are url safe.
1312
3238
        repository_transport = a_bzrdir.get_repository_transport(self)
1313
 
        control_files = LockableFiles(repository_transport, 'lock', LockDir)
 
3239
        control_files = lockable_files.LockableFiles(repository_transport,
 
3240
                                'lock', lockdir.LockDir)
1314
3241
        control_files.create_lock()
1315
3242
        return control_files
1316
3243
 
1318
3245
        """Upload the initial blank content."""
1319
3246
        control_files = self._create_control_files(a_bzrdir)
1320
3247
        control_files.lock_write()
 
3248
        transport = control_files._transport
 
3249
        if shared == True:
 
3250
            utf8_files += [('shared-storage', '')]
1321
3251
        try:
1322
 
            control_files._transport.mkdir_multi(dirs,
1323
 
                    mode=control_files._dir_mode)
1324
 
            for file, content in files:
1325
 
                control_files.put(file, content)
1326
 
            for file, content in utf8_files:
1327
 
                control_files.put_utf8(file, content)
1328
 
            if shared == True:
1329
 
                control_files.put_utf8('shared-storage', '')
 
3252
            transport.mkdir_multi(dirs, mode=a_bzrdir._get_dir_mode())
 
3253
            for (filename, content_stream) in files:
 
3254
                transport.put_file(filename, content_stream,
 
3255
                    mode=a_bzrdir._get_file_mode())
 
3256
            for (filename, content_bytes) in utf8_files:
 
3257
                transport.put_bytes_non_atomic(filename, content_bytes,
 
3258
                    mode=a_bzrdir._get_file_mode())
1330
3259
        finally:
1331
3260
            control_files.unlock()
1332
3261
 
1333
 
 
1334
 
class RepositoryFormat7(MetaDirRepositoryFormat):
1335
 
    """Bzr repository 7.
1336
 
 
1337
 
    This repository format has:
1338
 
     - weaves for file texts and inventory
1339
 
     - hash subdirectory based stores.
1340
 
     - TextStores for revisions and signatures.
1341
 
     - a format marker of its own
1342
 
     - an optional 'shared-storage' flag
1343
 
     - an optional 'no-working-trees' flag
1344
 
    """
1345
 
 
1346
 
    def _get_control_store(self, repo_transport, control_files):
1347
 
        """Return the control store for this repository."""
1348
 
        return self._get_versioned_file_store('',
1349
 
                                              repo_transport,
1350
 
                                              control_files,
1351
 
                                              prefixed=False)
1352
 
 
1353
 
    def get_format_string(self):
1354
 
        """See RepositoryFormat.get_format_string()."""
1355
 
        return "Bazaar-NG Repository format 7"
1356
 
 
1357
 
    def get_format_description(self):
1358
 
        """See RepositoryFormat.get_format_description()."""
1359
 
        return "Weave repository format 7"
1360
 
 
1361
 
    def _get_revision_store(self, repo_transport, control_files):
1362
 
        """See RepositoryFormat._get_revision_store()."""
1363
 
        return self._get_text_rev_store(repo_transport,
1364
 
                                        control_files,
1365
 
                                        'revision-store',
1366
 
                                        compressed=False,
1367
 
                                        prefixed=True,
1368
 
                                        )
1369
 
 
1370
 
    def _get_text_store(self, transport, control_files):
1371
 
        """See RepositoryFormat._get_text_store()."""
1372
 
        return self._get_versioned_file_store('weaves',
1373
 
                                              transport,
1374
 
                                              control_files)
1375
 
 
1376
 
    def initialize(self, a_bzrdir, shared=False):
1377
 
        """Create a weave repository.
1378
 
 
1379
 
        :param shared: If true the repository will be initialized as a shared
1380
 
                       repository.
1381
 
        """
1382
 
        from bzrlib.weavefile import write_weave_v5
1383
 
        from bzrlib.weave import Weave
1384
 
 
1385
 
        # Create an empty weave
1386
 
        sio = StringIO()
1387
 
        write_weave_v5(Weave(), sio)
1388
 
        empty_weave = sio.getvalue()
1389
 
 
1390
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
1391
 
        dirs = ['revision-store', 'weaves']
1392
 
        files = [('inventory.weave', StringIO(empty_weave)), 
1393
 
                 ]
1394
 
        utf8_files = [('format', self.get_format_string())]
1395
 
 
1396
 
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1397
 
        return self.open(a_bzrdir=a_bzrdir, _found=True)
1398
 
 
1399
 
    def open(self, a_bzrdir, _found=False, _override_transport=None):
1400
 
        """See RepositoryFormat.open().
1401
 
        
1402
 
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
1403
 
                                    repository at a slightly different url
1404
 
                                    than normal. I.e. during 'upgrade'.
1405
 
        """
1406
 
        if not _found:
1407
 
            format = RepositoryFormat.find_format(a_bzrdir)
1408
 
            assert format.__class__ ==  self.__class__
1409
 
        if _override_transport is not None:
1410
 
            repo_transport = _override_transport
1411
 
        else:
1412
 
            repo_transport = a_bzrdir.get_repository_transport(None)
1413
 
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
1414
 
        text_store = self._get_text_store(repo_transport, control_files)
1415
 
        control_store = self._get_control_store(repo_transport, control_files)
1416
 
        _revision_store = self._get_revision_store(repo_transport, control_files)
1417
 
        return MetaDirRepository(_format=self,
1418
 
                                 a_bzrdir=a_bzrdir,
1419
 
                                 control_files=control_files,
1420
 
                                 _revision_store=_revision_store,
1421
 
                                 control_store=control_store,
1422
 
                                 text_store=text_store)
1423
 
 
1424
 
 
1425
 
class RepositoryFormatKnit1(MetaDirRepositoryFormat):
1426
 
    """Bzr repository knit format 1.
1427
 
 
1428
 
    This repository format has:
1429
 
     - knits for file texts and inventory
1430
 
     - hash subdirectory based stores.
1431
 
     - knits for revisions and signatures
1432
 
     - TextStores for revisions and signatures.
1433
 
     - a format marker of its own
1434
 
     - an optional 'shared-storage' flag
1435
 
     - an optional 'no-working-trees' flag
1436
 
     - a LockDir lock
1437
 
 
1438
 
    This format was introduced in bzr 0.8.
1439
 
    """
1440
 
 
1441
 
    def _get_control_store(self, repo_transport, control_files):
1442
 
        """Return the control store for this repository."""
1443
 
        return VersionedFileStore(
1444
 
            repo_transport,
1445
 
            prefixed=False,
1446
 
            file_mode=control_files._file_mode,
1447
 
            versionedfile_class=KnitVersionedFile,
1448
 
            versionedfile_kwargs={'factory':KnitPlainFactory()},
1449
 
            )
1450
 
 
1451
 
    def get_format_string(self):
1452
 
        """See RepositoryFormat.get_format_string()."""
1453
 
        return "Bazaar-NG Knit Repository Format 1"
1454
 
 
1455
 
    def get_format_description(self):
1456
 
        """See RepositoryFormat.get_format_description()."""
1457
 
        return "Knit repository format 1"
1458
 
 
1459
 
    def _get_revision_store(self, repo_transport, control_files):
1460
 
        """See RepositoryFormat._get_revision_store()."""
1461
 
        from bzrlib.store.revision.knit import KnitRevisionStore
1462
 
        versioned_file_store = VersionedFileStore(
1463
 
            repo_transport,
1464
 
            file_mode=control_files._file_mode,
1465
 
            prefixed=False,
1466
 
            precious=True,
1467
 
            versionedfile_class=KnitVersionedFile,
1468
 
            versionedfile_kwargs={'delta':False, 'factory':KnitPlainFactory()},
1469
 
            escaped=True,
1470
 
            )
1471
 
        return KnitRevisionStore(versioned_file_store)
1472
 
 
1473
 
    def _get_text_store(self, transport, control_files):
1474
 
        """See RepositoryFormat._get_text_store()."""
1475
 
        return self._get_versioned_file_store('knits',
1476
 
                                              transport,
1477
 
                                              control_files,
1478
 
                                              versionedfile_class=KnitVersionedFile,
1479
 
                                              escaped=True)
1480
 
 
1481
 
    def initialize(self, a_bzrdir, shared=False):
1482
 
        """Create a knit format 1 repository.
1483
 
 
1484
 
        :param a_bzrdir: bzrdir to contain the new repository; must already
1485
 
            be initialized.
1486
 
        :param shared: If true the repository will be initialized as a shared
1487
 
                       repository.
1488
 
        """
1489
 
        mutter('creating repository in %s.', a_bzrdir.transport.base)
1490
 
        dirs = ['revision-store', 'knits']
1491
 
        files = []
1492
 
        utf8_files = [('format', self.get_format_string())]
1493
 
        
1494
 
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1495
 
        repo_transport = a_bzrdir.get_repository_transport(None)
1496
 
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
1497
 
        control_store = self._get_control_store(repo_transport, control_files)
1498
 
        transaction = transactions.WriteTransaction()
1499
 
        # trigger a write of the inventory store.
1500
 
        control_store.get_weave_or_empty('inventory', transaction)
1501
 
        _revision_store = self._get_revision_store(repo_transport, control_files)
1502
 
        _revision_store.has_revision_id('A', transaction)
1503
 
        _revision_store.get_signature_file(transaction)
1504
 
        return self.open(a_bzrdir=a_bzrdir, _found=True)
1505
 
 
1506
 
    def open(self, a_bzrdir, _found=False, _override_transport=None):
1507
 
        """See RepositoryFormat.open().
1508
 
        
1509
 
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
1510
 
                                    repository at a slightly different url
1511
 
                                    than normal. I.e. during 'upgrade'.
1512
 
        """
1513
 
        if not _found:
1514
 
            format = RepositoryFormat.find_format(a_bzrdir)
1515
 
            assert format.__class__ ==  self.__class__
1516
 
        if _override_transport is not None:
1517
 
            repo_transport = _override_transport
1518
 
        else:
1519
 
            repo_transport = a_bzrdir.get_repository_transport(None)
1520
 
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
1521
 
        text_store = self._get_text_store(repo_transport, control_files)
1522
 
        control_store = self._get_control_store(repo_transport, control_files)
1523
 
        _revision_store = self._get_revision_store(repo_transport, control_files)
1524
 
        return KnitRepository(_format=self,
1525
 
                              a_bzrdir=a_bzrdir,
1526
 
                              control_files=control_files,
1527
 
                              _revision_store=_revision_store,
1528
 
                              control_store=control_store,
1529
 
                              text_store=text_store)
1530
 
 
1531
 
 
1532
 
# formats which have no format string are not discoverable
1533
 
# and not independently creatable, so are not registered.
1534
 
RepositoryFormat.register_format(RepositoryFormat7())
1535
 
_default_format = RepositoryFormatKnit1()
1536
 
RepositoryFormat.register_format(_default_format)
1537
 
RepositoryFormat.set_default_format(_default_format)
1538
 
_legacy_formats = [RepositoryFormat4(),
1539
 
                   RepositoryFormat5(),
1540
 
                   RepositoryFormat6()]
 
3262
    def network_name(self):
 
3263
        """Metadir formats have matching disk and network format strings."""
 
3264
        return self.get_format_string()
 
3265
 
 
3266
 
 
3267
# Pre-0.8 formats that don't have a disk format string (because they are
 
3268
# versioned by the matching control directory). We use the control directories
 
3269
# disk format string as a key for the network_name because they meet the
 
3270
# constraints (simple string, unique, immutable).
 
3271
network_format_registry.register_lazy(
 
3272
    "Bazaar-NG branch, format 5\n",
 
3273
    'bzrlib.repofmt.weaverepo',
 
3274
    'RepositoryFormat5',
 
3275
)
 
3276
network_format_registry.register_lazy(
 
3277
    "Bazaar-NG branch, format 6\n",
 
3278
    'bzrlib.repofmt.weaverepo',
 
3279
    'RepositoryFormat6',
 
3280
)
 
3281
 
 
3282
# formats which have no format string are not discoverable or independently
 
3283
# creatable on disk, so are not registered in format_registry.  They're
 
3284
# all in bzrlib.repofmt.weaverepo now.  When an instance of one of these is
 
3285
# needed, it's constructed directly by the BzrDir.  Non-native formats where
 
3286
# the repository is not separately opened are similar.
 
3287
 
 
3288
format_registry.register_lazy(
 
3289
    'Bazaar-NG Repository format 7',
 
3290
    'bzrlib.repofmt.weaverepo',
 
3291
    'RepositoryFormat7'
 
3292
    )
 
3293
 
 
3294
format_registry.register_lazy(
 
3295
    'Bazaar-NG Knit Repository Format 1',
 
3296
    'bzrlib.repofmt.knitrepo',
 
3297
    'RepositoryFormatKnit1',
 
3298
    )
 
3299
 
 
3300
format_registry.register_lazy(
 
3301
    'Bazaar Knit Repository Format 3 (bzr 0.15)\n',
 
3302
    'bzrlib.repofmt.knitrepo',
 
3303
    'RepositoryFormatKnit3',
 
3304
    )
 
3305
 
 
3306
format_registry.register_lazy(
 
3307
    'Bazaar Knit Repository Format 4 (bzr 1.0)\n',
 
3308
    'bzrlib.repofmt.knitrepo',
 
3309
    'RepositoryFormatKnit4',
 
3310
    )
 
3311
 
 
3312
# Pack-based formats. There is one format for pre-subtrees, and one for
 
3313
# post-subtrees to allow ease of testing.
 
3314
# NOTE: These are experimental in 0.92. Stable in 1.0 and above
 
3315
format_registry.register_lazy(
 
3316
    'Bazaar pack repository format 1 (needs bzr 0.92)\n',
 
3317
    'bzrlib.repofmt.pack_repo',
 
3318
    'RepositoryFormatKnitPack1',
 
3319
    )
 
3320
format_registry.register_lazy(
 
3321
    'Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n',
 
3322
    'bzrlib.repofmt.pack_repo',
 
3323
    'RepositoryFormatKnitPack3',
 
3324
    )
 
3325
format_registry.register_lazy(
 
3326
    'Bazaar pack repository format 1 with rich root (needs bzr 1.0)\n',
 
3327
    'bzrlib.repofmt.pack_repo',
 
3328
    'RepositoryFormatKnitPack4',
 
3329
    )
 
3330
format_registry.register_lazy(
 
3331
    'Bazaar RepositoryFormatKnitPack5 (bzr 1.6)\n',
 
3332
    'bzrlib.repofmt.pack_repo',
 
3333
    'RepositoryFormatKnitPack5',
 
3334
    )
 
3335
format_registry.register_lazy(
 
3336
    'Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n',
 
3337
    'bzrlib.repofmt.pack_repo',
 
3338
    'RepositoryFormatKnitPack5RichRoot',
 
3339
    )
 
3340
format_registry.register_lazy(
 
3341
    'Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n',
 
3342
    'bzrlib.repofmt.pack_repo',
 
3343
    'RepositoryFormatKnitPack5RichRootBroken',
 
3344
    )
 
3345
format_registry.register_lazy(
 
3346
    'Bazaar RepositoryFormatKnitPack6 (bzr 1.9)\n',
 
3347
    'bzrlib.repofmt.pack_repo',
 
3348
    'RepositoryFormatKnitPack6',
 
3349
    )
 
3350
format_registry.register_lazy(
 
3351
    'Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n',
 
3352
    'bzrlib.repofmt.pack_repo',
 
3353
    'RepositoryFormatKnitPack6RichRoot',
 
3354
    )
 
3355
 
 
3356
# Development formats.
 
3357
# Obsolete but kept pending a CHK based subtree format.
 
3358
format_registry.register_lazy(
 
3359
    ("Bazaar development format 2 with subtree support "
 
3360
        "(needs bzr.dev from before 1.8)\n"),
 
3361
    'bzrlib.repofmt.pack_repo',
 
3362
    'RepositoryFormatPackDevelopment2Subtree',
 
3363
    )
 
3364
 
 
3365
# 1.14->1.16 go below here
 
3366
format_registry.register_lazy(
 
3367
    'Bazaar development format - group compression and chk inventory'
 
3368
        ' (needs bzr.dev from 1.14)\n',
 
3369
    'bzrlib.repofmt.groupcompress_repo',
 
3370
    'RepositoryFormatCHK1',
 
3371
    )
 
3372
 
 
3373
format_registry.register_lazy(
 
3374
    'Bazaar development format - chk repository with bencode revision '
 
3375
        'serialization (needs bzr.dev from 1.16)\n',
 
3376
    'bzrlib.repofmt.groupcompress_repo',
 
3377
    'RepositoryFormatCHK2',
 
3378
    )
 
3379
format_registry.register_lazy(
 
3380
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
 
3381
    'bzrlib.repofmt.groupcompress_repo',
 
3382
    'RepositoryFormat2a',
 
3383
    )
 
3384
format_registry.register_lazy(
 
3385
    'Bazaar development format 8\n',
 
3386
    'bzrlib.repofmt.groupcompress_repo',
 
3387
    'RepositoryFormat2aSubtree',
 
3388
    )
1541
3389
 
1542
3390
 
1543
3391
class InterRepository(InterObject):
1544
3392
    """This class represents operations taking place between two repositories.
1545
3393
 
1546
3394
    Its instances have methods like copy_content and fetch, and contain
1547
 
    references to the source and target repositories these operations can be 
 
3395
    references to the source and target repositories these operations can be
1548
3396
    carried out on.
1549
3397
 
1550
3398
    Often we will provide convenience methods on 'repository' which carry out
1552
3400
    InterRepository.get(other).method_name(parameters).
1553
3401
    """
1554
3402
 
1555
 
    _optimisers = set()
 
3403
    _walk_to_common_revisions_batch_size = 50
 
3404
    _optimisers = []
1556
3405
    """The available optimised InterRepository types."""
1557
3406
 
1558
3407
    @needs_write_lock
1559
 
    def copy_content(self, revision_id=None, basis=None):
 
3408
    def copy_content(self, revision_id=None):
1560
3409
        """Make a complete copy of the content in self into destination.
1561
 
        
1562
 
        This is a destructive operation! Do not use it on existing 
 
3410
 
 
3411
        This is a destructive operation! Do not use it on existing
1563
3412
        repositories.
1564
3413
 
1565
3414
        :param revision_id: Only copy the content needed to construct
1566
3415
                            revision_id and its parents.
1567
 
        :param basis: Copy the needed data preferentially from basis.
1568
3416
        """
1569
3417
        try:
1570
3418
            self.target.set_make_working_trees(self.source.make_working_trees())
1571
3419
        except NotImplementedError:
1572
3420
            pass
1573
 
        # grab the basis available data
1574
 
        if basis is not None:
1575
 
            self.target.fetch(basis, revision_id=revision_id)
1576
 
        # but don't bother fetching if we have the needed data now.
1577
 
        if (revision_id not in (None, NULL_REVISION) and 
1578
 
            self.target.has_revision(revision_id)):
1579
 
            return
1580
3421
        self.target.fetch(self.source, revision_id=revision_id)
1581
3422
 
1582
 
    def _double_lock(self, lock_source, lock_target):
1583
 
        """Take out too locks, rolling back the first if the second throws."""
1584
 
        lock_source()
1585
 
        try:
1586
 
            lock_target()
1587
 
        except Exception:
1588
 
            # we want to ensure that we don't leave source locked by mistake.
1589
 
            # and any error on target should not confuse source.
1590
 
            self.source.unlock()
1591
 
            raise
1592
 
 
1593
3423
    @needs_write_lock
1594
 
    def fetch(self, revision_id=None, pb=None):
 
3424
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
 
3425
            fetch_spec=None):
1595
3426
        """Fetch the content required to construct revision_id.
1596
3427
 
1597
 
        The content is copied from source to target.
 
3428
        The content is copied from self.source to self.target.
1598
3429
 
1599
3430
        :param revision_id: if None all content is copied, if NULL_REVISION no
1600
3431
                            content is copied.
1601
 
        :param pb: optional progress bar to use for progress reports. If not
1602
 
                   provided a default one will be created.
1603
 
 
1604
 
        Returns the copied revision count and the failed revisions in a tuple:
1605
 
        (copied, failures).
 
3432
        :param pb: ignored.
 
3433
        :return: None.
1606
3434
        """
1607
 
        from bzrlib.fetch import GenericRepoFetcher
1608
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1609
 
               self.source, self.source._format, self.target, self.target._format)
1610
 
        f = GenericRepoFetcher(to_repository=self.target,
 
3435
        ui.ui_factory.warn_experimental_format_fetch(self)
 
3436
        from bzrlib.fetch import RepoFetcher
 
3437
        # See <https://launchpad.net/bugs/456077> asking for a warning here
 
3438
        if self.source._format.network_name() != self.target._format.network_name():
 
3439
            ui.ui_factory.show_user_warning('cross_format_fetch',
 
3440
                from_format=self.source._format,
 
3441
                to_format=self.target._format)
 
3442
        f = RepoFetcher(to_repository=self.target,
1611
3443
                               from_repository=self.source,
1612
3444
                               last_revision=revision_id,
1613
 
                               pb=pb)
1614
 
        return f.count_copied, f.failed_revisions
1615
 
 
1616
 
    def lock_read(self):
1617
 
        """Take out a logical read lock.
1618
 
 
1619
 
        This will lock the source branch and the target branch. The source gets
1620
 
        a read lock and the target a read lock.
1621
 
        """
1622
 
        self._double_lock(self.source.lock_read, self.target.lock_read)
1623
 
 
1624
 
    def lock_write(self):
1625
 
        """Take out a logical write lock.
1626
 
 
1627
 
        This will lock the source branch and the target branch. The source gets
1628
 
        a read lock and the target a write lock.
1629
 
        """
1630
 
        self._double_lock(self.source.lock_read, self.target.lock_write)
 
3445
                               fetch_spec=fetch_spec,
 
3446
                               find_ghosts=find_ghosts)
 
3447
 
 
3448
    def _walk_to_common_revisions(self, revision_ids):
 
3449
        """Walk out from revision_ids in source to revisions target has.
 
3450
 
 
3451
        :param revision_ids: The start point for the search.
 
3452
        :return: A set of revision ids.
 
3453
        """
 
3454
        target_graph = self.target.get_graph()
 
3455
        revision_ids = frozenset(revision_ids)
 
3456
        missing_revs = set()
 
3457
        source_graph = self.source.get_graph()
 
3458
        # ensure we don't pay silly lookup costs.
 
3459
        searcher = source_graph._make_breadth_first_searcher(revision_ids)
 
3460
        null_set = frozenset([_mod_revision.NULL_REVISION])
 
3461
        searcher_exhausted = False
 
3462
        while True:
 
3463
            next_revs = set()
 
3464
            ghosts = set()
 
3465
            # Iterate the searcher until we have enough next_revs
 
3466
            while len(next_revs) < self._walk_to_common_revisions_batch_size:
 
3467
                try:
 
3468
                    next_revs_part, ghosts_part = searcher.next_with_ghosts()
 
3469
                    next_revs.update(next_revs_part)
 
3470
                    ghosts.update(ghosts_part)
 
3471
                except StopIteration:
 
3472
                    searcher_exhausted = True
 
3473
                    break
 
3474
            # If there are ghosts in the source graph, and the caller asked for
 
3475
            # them, make sure that they are present in the target.
 
3476
            # We don't care about other ghosts as we can't fetch them and
 
3477
            # haven't been asked to.
 
3478
            ghosts_to_check = set(revision_ids.intersection(ghosts))
 
3479
            revs_to_get = set(next_revs).union(ghosts_to_check)
 
3480
            if revs_to_get:
 
3481
                have_revs = set(target_graph.get_parent_map(revs_to_get))
 
3482
                # we always have NULL_REVISION present.
 
3483
                have_revs = have_revs.union(null_set)
 
3484
                # Check if the target is missing any ghosts we need.
 
3485
                ghosts_to_check.difference_update(have_revs)
 
3486
                if ghosts_to_check:
 
3487
                    # One of the caller's revision_ids is a ghost in both the
 
3488
                    # source and the target.
 
3489
                    raise errors.NoSuchRevision(
 
3490
                        self.source, ghosts_to_check.pop())
 
3491
                missing_revs.update(next_revs - have_revs)
 
3492
                # Because we may have walked past the original stop point, make
 
3493
                # sure everything is stopped
 
3494
                stop_revs = searcher.find_seen_ancestors(have_revs)
 
3495
                searcher.stop_searching_any(stop_revs)
 
3496
            if searcher_exhausted:
 
3497
                break
 
3498
        return searcher.get_result()
1631
3499
 
1632
3500
    @needs_read_lock
1633
 
    def missing_revision_ids(self, revision_id=None):
 
3501
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1634
3502
        """Return the revision ids that source has that target does not.
1635
 
        
1636
 
        These are returned in topological order.
1637
3503
 
1638
3504
        :param revision_id: only return revision ids included by this
1639
3505
                            revision_id.
 
3506
        :param find_ghosts: If True find missing revisions in deep history
 
3507
            rather than just finding the surface difference.
 
3508
        :return: A bzrlib.graph.SearchResult.
1640
3509
        """
 
3510
        # stop searching at found target revisions.
 
3511
        if not find_ghosts and revision_id is not None:
 
3512
            return self._walk_to_common_revisions([revision_id])
1641
3513
        # generic, possibly worst case, slow code path.
1642
3514
        target_ids = set(self.target.all_revision_ids())
1643
3515
        if revision_id is not None:
1644
3516
            source_ids = self.source.get_ancestry(revision_id)
1645
 
            assert source_ids[0] == None
 
3517
            if source_ids[0] is not None:
 
3518
                raise AssertionError()
1646
3519
            source_ids.pop(0)
1647
3520
        else:
1648
3521
            source_ids = self.source.all_revision_ids()
1649
3522
        result_set = set(source_ids).difference(target_ids)
1650
 
        # this may look like a no-op: its not. It preserves the ordering
1651
 
        # other_ids had while only returning the members from other_ids
1652
 
        # that we've decided we need.
1653
 
        return [rev_id for rev_id in source_ids if rev_id in result_set]
1654
 
 
1655
 
    def unlock(self):
1656
 
        """Release the locks on source and target."""
 
3523
        return self.source.revision_ids_to_search_result(result_set)
 
3524
 
 
3525
    @staticmethod
 
3526
    def _same_model(source, target):
 
3527
        """True if source and target have the same data representation.
 
3528
 
 
3529
        Note: this is always called on the base class; overriding it in a
 
3530
        subclass will have no effect.
 
3531
        """
1657
3532
        try:
1658
 
            self.target.unlock()
1659
 
        finally:
1660
 
            self.source.unlock()
1661
 
 
1662
 
 
1663
 
class InterWeaveRepo(InterRepository):
1664
 
    """Optimised code paths between Weave based repositories."""
1665
 
 
1666
 
    _matching_repo_format = RepositoryFormat7()
1667
 
    """Repository format for testing with."""
 
3533
            InterRepository._assert_same_model(source, target)
 
3534
            return True
 
3535
        except errors.IncompatibleRepositories, e:
 
3536
            return False
 
3537
 
 
3538
    @staticmethod
 
3539
    def _assert_same_model(source, target):
 
3540
        """Raise an exception if two repositories do not use the same model.
 
3541
        """
 
3542
        if source.supports_rich_root() != target.supports_rich_root():
 
3543
            raise errors.IncompatibleRepositories(source, target,
 
3544
                "different rich-root support")
 
3545
        if source._serializer != target._serializer:
 
3546
            raise errors.IncompatibleRepositories(source, target,
 
3547
                "different serializers")
 
3548
 
 
3549
 
 
3550
class InterSameDataRepository(InterRepository):
 
3551
    """Code for converting between repositories that represent the same data.
 
3552
 
 
3553
    Data format and model must match for this to work.
 
3554
    """
 
3555
 
 
3556
    @classmethod
 
3557
    def _get_repo_format_to_test(self):
 
3558
        """Repository format for testing with.
 
3559
 
 
3560
        InterSameData can pull from subtree to subtree and from non-subtree to
 
3561
        non-subtree, so we test this with the richest repository format.
 
3562
        """
 
3563
        from bzrlib.repofmt import knitrepo
 
3564
        return knitrepo.RepositoryFormatKnit3()
 
3565
 
 
3566
    @staticmethod
 
3567
    def is_compatible(source, target):
 
3568
        return InterRepository._same_model(source, target)
 
3569
 
 
3570
 
 
3571
class InterWeaveRepo(InterSameDataRepository):
 
3572
    """Optimised code paths between Weave based repositories.
 
3573
 
 
3574
    This should be in bzrlib/repofmt/weaverepo.py but we have not yet
 
3575
    implemented lazy inter-object optimisation.
 
3576
    """
 
3577
 
 
3578
    @classmethod
 
3579
    def _get_repo_format_to_test(self):
 
3580
        from bzrlib.repofmt import weaverepo
 
3581
        return weaverepo.RepositoryFormat7()
1668
3582
 
1669
3583
    @staticmethod
1670
3584
    def is_compatible(source, target):
1671
3585
        """Be compatible with known Weave formats.
1672
 
        
 
3586
 
1673
3587
        We don't test for the stores being of specific types because that
1674
 
        could lead to confusing results, and there is no need to be 
 
3588
        could lead to confusing results, and there is no need to be
1675
3589
        overly general.
1676
3590
        """
 
3591
        from bzrlib.repofmt.weaverepo import (
 
3592
                RepositoryFormat5,
 
3593
                RepositoryFormat6,
 
3594
                RepositoryFormat7,
 
3595
                )
1677
3596
        try:
1678
3597
            return (isinstance(source._format, (RepositoryFormat5,
1679
3598
                                                RepositoryFormat6,
1683
3602
                                                RepositoryFormat7)))
1684
3603
        except AttributeError:
1685
3604
            return False
1686
 
    
 
3605
 
1687
3606
    @needs_write_lock
1688
 
    def copy_content(self, revision_id=None, basis=None):
 
3607
    def copy_content(self, revision_id=None):
1689
3608
        """See InterRepository.copy_content()."""
1690
3609
        # weave specific optimised path:
1691
 
        if basis is not None:
1692
 
            # copy the basis in, then fetch remaining data.
1693
 
            basis.copy_content_into(self.target, revision_id)
1694
 
            # the basis copy_content_into could miss-set this.
 
3610
        try:
 
3611
            self.target.set_make_working_trees(self.source.make_working_trees())
 
3612
        except (errors.RepositoryUpgradeRequired, NotImplemented):
 
3613
            pass
 
3614
        # FIXME do not peek!
 
3615
        if self.source._transport.listable():
 
3616
            pb = ui.ui_factory.nested_progress_bar()
1695
3617
            try:
1696
 
                self.target.set_make_working_trees(self.source.make_working_trees())
1697
 
            except NotImplementedError:
1698
 
                pass
 
3618
                self.target.texts.insert_record_stream(
 
3619
                    self.source.texts.get_record_stream(
 
3620
                        self.source.texts.keys(), 'topological', False))
 
3621
                pb.update('Copying inventory', 0, 1)
 
3622
                self.target.inventories.insert_record_stream(
 
3623
                    self.source.inventories.get_record_stream(
 
3624
                        self.source.inventories.keys(), 'topological', False))
 
3625
                self.target.signatures.insert_record_stream(
 
3626
                    self.source.signatures.get_record_stream(
 
3627
                        self.source.signatures.keys(),
 
3628
                        'unordered', True))
 
3629
                self.target.revisions.insert_record_stream(
 
3630
                    self.source.revisions.get_record_stream(
 
3631
                        self.source.revisions.keys(),
 
3632
                        'topological', True))
 
3633
            finally:
 
3634
                pb.finished()
 
3635
        else:
1699
3636
            self.target.fetch(self.source, revision_id=revision_id)
1700
 
        else:
1701
 
            try:
1702
 
                self.target.set_make_working_trees(self.source.make_working_trees())
1703
 
            except NotImplementedError:
1704
 
                pass
1705
 
            # FIXME do not peek!
1706
 
            if self.source.control_files._transport.listable():
1707
 
                pb = ui.ui_factory.nested_progress_bar()
1708
 
                try:
1709
 
                    self.target.weave_store.copy_all_ids(
1710
 
                        self.source.weave_store,
1711
 
                        pb=pb,
1712
 
                        from_transaction=self.source.get_transaction(),
1713
 
                        to_transaction=self.target.get_transaction())
1714
 
                    pb.update('copying inventory', 0, 1)
1715
 
                    self.target.control_weaves.copy_multi(
1716
 
                        self.source.control_weaves, ['inventory'],
1717
 
                        from_transaction=self.source.get_transaction(),
1718
 
                        to_transaction=self.target.get_transaction())
1719
 
                    self.target._revision_store.text_store.copy_all_ids(
1720
 
                        self.source._revision_store.text_store,
1721
 
                        pb=pb)
1722
 
                finally:
1723
 
                    pb.finished()
1724
 
            else:
1725
 
                self.target.fetch(self.source, revision_id=revision_id)
1726
 
 
1727
 
    @needs_write_lock
1728
 
    def fetch(self, revision_id=None, pb=None):
1729
 
        """See InterRepository.fetch()."""
1730
 
        from bzrlib.fetch import GenericRepoFetcher
1731
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1732
 
               self.source, self.source._format, self.target, self.target._format)
1733
 
        f = GenericRepoFetcher(to_repository=self.target,
1734
 
                               from_repository=self.source,
1735
 
                               last_revision=revision_id,
1736
 
                               pb=pb)
1737
 
        return f.count_copied, f.failed_revisions
1738
3637
 
1739
3638
    @needs_read_lock
1740
 
    def missing_revision_ids(self, revision_id=None):
 
3639
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1741
3640
        """See InterRepository.missing_revision_ids()."""
1742
3641
        # we want all revisions to satisfy revision_id in source.
1743
3642
        # but we don't want to stat every file here and there.
1744
 
        # we want then, all revisions other needs to satisfy revision_id 
 
3643
        # we want then, all revisions other needs to satisfy revision_id
1745
3644
        # checked, but not those that we have locally.
1746
 
        # so the first thing is to get a subset of the revisions to 
 
3645
        # so the first thing is to get a subset of the revisions to
1747
3646
        # satisfy revision_id in source, and then eliminate those that
1748
 
        # we do already have. 
1749
 
        # this is slow on high latency connection to self, but as as this
1750
 
        # disk format scales terribly for push anyway due to rewriting 
 
3647
        # we do already have.
 
3648
        # this is slow on high latency connection to self, but as this
 
3649
        # disk format scales terribly for push anyway due to rewriting
1751
3650
        # inventory.weave, this is considered acceptable.
1752
3651
        # - RBC 20060209
1753
3652
        if revision_id is not None:
1754
3653
            source_ids = self.source.get_ancestry(revision_id)
1755
 
            assert source_ids[0] == None
 
3654
            if source_ids[0] is not None:
 
3655
                raise AssertionError()
1756
3656
            source_ids.pop(0)
1757
3657
        else:
1758
3658
            source_ids = self.source._all_possible_ids()
1763
3663
        # we do not have a revision as that would be pointless.
1764
3664
        target_ids = set(self.target._all_possible_ids())
1765
3665
        possibly_present_revisions = target_ids.intersection(source_ids_set)
1766
 
        actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
3666
        actually_present_revisions = set(
 
3667
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
1767
3668
        required_revisions = source_ids_set.difference(actually_present_revisions)
1768
 
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1769
3669
        if revision_id is not None:
1770
3670
            # we used get_ancestry to determine source_ids then we are assured all
1771
3671
            # revisions referenced are present as they are installed in topological order.
1772
3672
            # and the tip revision was validated by get_ancestry.
1773
 
            return required_topo_revisions
 
3673
            result_set = required_revisions
1774
3674
        else:
1775
 
            # if we just grabbed the possibly available ids, then 
 
3675
            # if we just grabbed the possibly available ids, then
1776
3676
            # we only have an estimate of whats available and need to validate
1777
3677
            # that against the revision records.
1778
 
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
1779
 
 
1780
 
 
1781
 
class InterKnitRepo(InterRepository):
 
3678
            result_set = set(
 
3679
                self.source._eliminate_revisions_not_present(required_revisions))
 
3680
        return self.source.revision_ids_to_search_result(result_set)
 
3681
 
 
3682
 
 
3683
class InterKnitRepo(InterSameDataRepository):
1782
3684
    """Optimised code paths between Knit based repositories."""
1783
3685
 
1784
 
    _matching_repo_format = RepositoryFormatKnit1()
1785
 
    """Repository format for testing with."""
 
3686
    @classmethod
 
3687
    def _get_repo_format_to_test(self):
 
3688
        from bzrlib.repofmt import knitrepo
 
3689
        return knitrepo.RepositoryFormatKnit1()
1786
3690
 
1787
3691
    @staticmethod
1788
3692
    def is_compatible(source, target):
1789
3693
        """Be compatible with known Knit formats.
1790
 
        
 
3694
 
1791
3695
        We don't test for the stores being of specific types because that
1792
 
        could lead to confusing results, and there is no need to be 
 
3696
        could lead to confusing results, and there is no need to be
1793
3697
        overly general.
1794
3698
        """
 
3699
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
1795
3700
        try:
1796
 
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
1797
 
                    isinstance(target._format, (RepositoryFormatKnit1)))
 
3701
            are_knits = (isinstance(source._format, RepositoryFormatKnit) and
 
3702
                isinstance(target._format, RepositoryFormatKnit))
1798
3703
        except AttributeError:
1799
3704
            return False
1800
 
 
1801
 
    @needs_write_lock
1802
 
    def fetch(self, revision_id=None, pb=None):
1803
 
        """See InterRepository.fetch()."""
1804
 
        from bzrlib.fetch import KnitRepoFetcher
1805
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1806
 
               self.source, self.source._format, self.target, self.target._format)
1807
 
        f = KnitRepoFetcher(to_repository=self.target,
1808
 
                            from_repository=self.source,
1809
 
                            last_revision=revision_id,
1810
 
                            pb=pb)
1811
 
        return f.count_copied, f.failed_revisions
 
3705
        return are_knits and InterRepository._same_model(source, target)
1812
3706
 
1813
3707
    @needs_read_lock
1814
 
    def missing_revision_ids(self, revision_id=None):
 
3708
    def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1815
3709
        """See InterRepository.missing_revision_ids()."""
1816
3710
        if revision_id is not None:
1817
3711
            source_ids = self.source.get_ancestry(revision_id)
1818
 
            assert source_ids[0] == None
 
3712
            if source_ids[0] is not None:
 
3713
                raise AssertionError()
1819
3714
            source_ids.pop(0)
1820
3715
        else:
1821
 
            source_ids = self.source._all_possible_ids()
 
3716
            source_ids = self.source.all_revision_ids()
1822
3717
        source_ids_set = set(source_ids)
1823
3718
        # source_ids is the worst possible case we may need to pull.
1824
3719
        # now we want to filter source_ids against what we actually
1825
3720
        # have in target, but don't try to check for existence where we know
1826
3721
        # we do not have a revision as that would be pointless.
1827
 
        target_ids = set(self.target._all_possible_ids())
 
3722
        target_ids = set(self.target.all_revision_ids())
1828
3723
        possibly_present_revisions = target_ids.intersection(source_ids_set)
1829
 
        actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
3724
        actually_present_revisions = set(
 
3725
            self.target._eliminate_revisions_not_present(possibly_present_revisions))
1830
3726
        required_revisions = source_ids_set.difference(actually_present_revisions)
1831
 
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
1832
3727
        if revision_id is not None:
1833
3728
            # we used get_ancestry to determine source_ids then we are assured all
1834
3729
            # revisions referenced are present as they are installed in topological order.
1835
3730
            # and the tip revision was validated by get_ancestry.
1836
 
            return required_topo_revisions
 
3731
            result_set = required_revisions
1837
3732
        else:
1838
 
            # if we just grabbed the possibly available ids, then 
 
3733
            # if we just grabbed the possibly available ids, then
1839
3734
            # we only have an estimate of whats available and need to validate
1840
3735
            # that against the revision records.
1841
 
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
1842
 
 
 
3736
            result_set = set(
 
3737
                self.source._eliminate_revisions_not_present(required_revisions))
 
3738
        return self.source.revision_ids_to_search_result(result_set)
 
3739
 
 
3740
 
 
3741
class InterDifferingSerializer(InterRepository):
 
3742
 
 
3743
    @classmethod
 
3744
    def _get_repo_format_to_test(self):
 
3745
        return None
 
3746
 
 
3747
    @staticmethod
 
3748
    def is_compatible(source, target):
 
3749
        """Be compatible with Knit2 source and Knit3 target"""
 
3750
        # This is redundant with format.check_conversion_target(), however that
 
3751
        # raises an exception, and we just want to say "False" as in we won't
 
3752
        # support converting between these formats.
 
3753
        if 'IDS_never' in debug.debug_flags:
 
3754
            return False
 
3755
        if source.supports_rich_root() and not target.supports_rich_root():
 
3756
            return False
 
3757
        if (source._format.supports_tree_reference
 
3758
            and not target._format.supports_tree_reference):
 
3759
            return False
 
3760
        if target._fallback_repositories and target._format.supports_chks:
 
3761
            # IDS doesn't know how to copy CHKs for the parent inventories it
 
3762
            # adds to stacked repos.
 
3763
            return False
 
3764
        if 'IDS_always' in debug.debug_flags:
 
3765
            return True
 
3766
        # Only use this code path for local source and target.  IDS does far
 
3767
        # too much IO (both bandwidth and roundtrips) over a network.
 
3768
        if not source.bzrdir.transport.base.startswith('file:///'):
 
3769
            return False
 
3770
        if not target.bzrdir.transport.base.startswith('file:///'):
 
3771
            return False
 
3772
        return True
 
3773
 
 
3774
    def _get_trees(self, revision_ids, cache):
 
3775
        possible_trees = []
 
3776
        for rev_id in revision_ids:
 
3777
            if rev_id in cache:
 
3778
                possible_trees.append((rev_id, cache[rev_id]))
 
3779
            else:
 
3780
                # Not cached, but inventory might be present anyway.
 
3781
                try:
 
3782
                    tree = self.source.revision_tree(rev_id)
 
3783
                except errors.NoSuchRevision:
 
3784
                    # Nope, parent is ghost.
 
3785
                    pass
 
3786
                else:
 
3787
                    cache[rev_id] = tree
 
3788
                    possible_trees.append((rev_id, tree))
 
3789
        return possible_trees
 
3790
 
 
3791
    def _get_delta_for_revision(self, tree, parent_ids, possible_trees):
 
3792
        """Get the best delta and base for this revision.
 
3793
 
 
3794
        :return: (basis_id, delta)
 
3795
        """
 
3796
        deltas = []
 
3797
        # Generate deltas against each tree, to find the shortest.
 
3798
        texts_possibly_new_in_tree = set()
 
3799
        for basis_id, basis_tree in possible_trees:
 
3800
            delta = tree.inventory._make_delta(basis_tree.inventory)
 
3801
            for old_path, new_path, file_id, new_entry in delta:
 
3802
                if new_path is None:
 
3803
                    # This file_id isn't present in the new rev, so we don't
 
3804
                    # care about it.
 
3805
                    continue
 
3806
                if not new_path:
 
3807
                    # Rich roots are handled elsewhere...
 
3808
                    continue
 
3809
                kind = new_entry.kind
 
3810
                if kind != 'directory' and kind != 'file':
 
3811
                    # No text record associated with this inventory entry.
 
3812
                    continue
 
3813
                # This is a directory or file that has changed somehow.
 
3814
                texts_possibly_new_in_tree.add((file_id, new_entry.revision))
 
3815
            deltas.append((len(delta), basis_id, delta))
 
3816
        deltas.sort()
 
3817
        return deltas[0][1:]
 
3818
 
 
3819
    def _fetch_parent_invs_for_stacking(self, parent_map, cache):
 
3820
        """Find all parent revisions that are absent, but for which the
 
3821
        inventory is present, and copy those inventories.
 
3822
 
 
3823
        This is necessary to preserve correctness when the source is stacked
 
3824
        without fallbacks configured.  (Note that in cases like upgrade the
 
3825
        source may be not have _fallback_repositories even though it is
 
3826
        stacked.)
 
3827
        """
 
3828
        parent_revs = set()
 
3829
        for parents in parent_map.values():
 
3830
            parent_revs.update(parents)
 
3831
        present_parents = self.source.get_parent_map(parent_revs)
 
3832
        absent_parents = set(parent_revs).difference(present_parents)
 
3833
        parent_invs_keys_for_stacking = self.source.inventories.get_parent_map(
 
3834
            (rev_id,) for rev_id in absent_parents)
 
3835
        parent_inv_ids = [key[-1] for key in parent_invs_keys_for_stacking]
 
3836
        for parent_tree in self.source.revision_trees(parent_inv_ids):
 
3837
            current_revision_id = parent_tree.get_revision_id()
 
3838
            parents_parents_keys = parent_invs_keys_for_stacking[
 
3839
                (current_revision_id,)]
 
3840
            parents_parents = [key[-1] for key in parents_parents_keys]
 
3841
            basis_id = _mod_revision.NULL_REVISION
 
3842
            basis_tree = self.source.revision_tree(basis_id)
 
3843
            delta = parent_tree.inventory._make_delta(basis_tree.inventory)
 
3844
            self.target.add_inventory_by_delta(
 
3845
                basis_id, delta, current_revision_id, parents_parents)
 
3846
            cache[current_revision_id] = parent_tree
 
3847
 
 
3848
    def _fetch_batch(self, revision_ids, basis_id, cache):
 
3849
        """Fetch across a few revisions.
 
3850
 
 
3851
        :param revision_ids: The revisions to copy
 
3852
        :param basis_id: The revision_id of a tree that must be in cache, used
 
3853
            as a basis for delta when no other base is available
 
3854
        :param cache: A cache of RevisionTrees that we can use.
 
3855
        :return: The revision_id of the last converted tree. The RevisionTree
 
3856
            for it will be in cache
 
3857
        """
 
3858
        # Walk though all revisions; get inventory deltas, copy referenced
 
3859
        # texts that delta references, insert the delta, revision and
 
3860
        # signature.
 
3861
        root_keys_to_create = set()
 
3862
        text_keys = set()
 
3863
        pending_deltas = []
 
3864
        pending_revisions = []
 
3865
        parent_map = self.source.get_parent_map(revision_ids)
 
3866
        self._fetch_parent_invs_for_stacking(parent_map, cache)
 
3867
        self.source._safe_to_return_from_cache = True
 
3868
        for tree in self.source.revision_trees(revision_ids):
 
3869
            # Find a inventory delta for this revision.
 
3870
            # Find text entries that need to be copied, too.
 
3871
            current_revision_id = tree.get_revision_id()
 
3872
            parent_ids = parent_map.get(current_revision_id, ())
 
3873
            parent_trees = self._get_trees(parent_ids, cache)
 
3874
            possible_trees = list(parent_trees)
 
3875
            if len(possible_trees) == 0:
 
3876
                # There either aren't any parents, or the parents are ghosts,
 
3877
                # so just use the last converted tree.
 
3878
                possible_trees.append((basis_id, cache[basis_id]))
 
3879
            basis_id, delta = self._get_delta_for_revision(tree, parent_ids,
 
3880
                                                           possible_trees)
 
3881
            revision = self.source.get_revision(current_revision_id)
 
3882
            pending_deltas.append((basis_id, delta,
 
3883
                current_revision_id, revision.parent_ids))
 
3884
            if self._converting_to_rich_root:
 
3885
                self._revision_id_to_root_id[current_revision_id] = \
 
3886
                    tree.get_root_id()
 
3887
            # Determine which texts are in present in this revision but not in
 
3888
            # any of the available parents.
 
3889
            texts_possibly_new_in_tree = set()
 
3890
            for old_path, new_path, file_id, entry in delta:
 
3891
                if new_path is None:
 
3892
                    # This file_id isn't present in the new rev
 
3893
                    continue
 
3894
                if not new_path:
 
3895
                    # This is the root
 
3896
                    if not self.target.supports_rich_root():
 
3897
                        # The target doesn't support rich root, so we don't
 
3898
                        # copy
 
3899
                        continue
 
3900
                    if self._converting_to_rich_root:
 
3901
                        # This can't be copied normally, we have to insert
 
3902
                        # it specially
 
3903
                        root_keys_to_create.add((file_id, entry.revision))
 
3904
                        continue
 
3905
                kind = entry.kind
 
3906
                texts_possibly_new_in_tree.add((file_id, entry.revision))
 
3907
            for basis_id, basis_tree in possible_trees:
 
3908
                basis_inv = basis_tree.inventory
 
3909
                for file_key in list(texts_possibly_new_in_tree):
 
3910
                    file_id, file_revision = file_key
 
3911
                    try:
 
3912
                        entry = basis_inv[file_id]
 
3913
                    except errors.NoSuchId:
 
3914
                        continue
 
3915
                    if entry.revision == file_revision:
 
3916
                        texts_possibly_new_in_tree.remove(file_key)
 
3917
            text_keys.update(texts_possibly_new_in_tree)
 
3918
            pending_revisions.append(revision)
 
3919
            cache[current_revision_id] = tree
 
3920
            basis_id = current_revision_id
 
3921
        self.source._safe_to_return_from_cache = False
 
3922
        # Copy file texts
 
3923
        from_texts = self.source.texts
 
3924
        to_texts = self.target.texts
 
3925
        if root_keys_to_create:
 
3926
            root_stream = _mod_fetch._new_root_data_stream(
 
3927
                root_keys_to_create, self._revision_id_to_root_id, parent_map,
 
3928
                self.source)
 
3929
            to_texts.insert_record_stream(root_stream)
 
3930
        to_texts.insert_record_stream(from_texts.get_record_stream(
 
3931
            text_keys, self.target._format._fetch_order,
 
3932
            not self.target._format._fetch_uses_deltas))
 
3933
        # insert inventory deltas
 
3934
        for delta in pending_deltas:
 
3935
            self.target.add_inventory_by_delta(*delta)
 
3936
        if self.target._fallback_repositories:
 
3937
            # Make sure this stacked repository has all the parent inventories
 
3938
            # for the new revisions that we are about to insert.  We do this
 
3939
            # before adding the revisions so that no revision is added until
 
3940
            # all the inventories it may depend on are added.
 
3941
            # Note that this is overzealous, as we may have fetched these in an
 
3942
            # earlier batch.
 
3943
            parent_ids = set()
 
3944
            revision_ids = set()
 
3945
            for revision in pending_revisions:
 
3946
                revision_ids.add(revision.revision_id)
 
3947
                parent_ids.update(revision.parent_ids)
 
3948
            parent_ids.difference_update(revision_ids)
 
3949
            parent_ids.discard(_mod_revision.NULL_REVISION)
 
3950
            parent_map = self.source.get_parent_map(parent_ids)
 
3951
            # we iterate over parent_map and not parent_ids because we don't
 
3952
            # want to try copying any revision which is a ghost
 
3953
            for parent_tree in self.source.revision_trees(parent_map):
 
3954
                current_revision_id = parent_tree.get_revision_id()
 
3955
                parents_parents = parent_map[current_revision_id]
 
3956
                possible_trees = self._get_trees(parents_parents, cache)
 
3957
                if len(possible_trees) == 0:
 
3958
                    # There either aren't any parents, or the parents are
 
3959
                    # ghosts, so just use the last converted tree.
 
3960
                    possible_trees.append((basis_id, cache[basis_id]))
 
3961
                basis_id, delta = self._get_delta_for_revision(parent_tree,
 
3962
                    parents_parents, possible_trees)
 
3963
                self.target.add_inventory_by_delta(
 
3964
                    basis_id, delta, current_revision_id, parents_parents)
 
3965
        # insert signatures and revisions
 
3966
        for revision in pending_revisions:
 
3967
            try:
 
3968
                signature = self.source.get_signature_text(
 
3969
                    revision.revision_id)
 
3970
                self.target.add_signature_text(revision.revision_id,
 
3971
                    signature)
 
3972
            except errors.NoSuchRevision:
 
3973
                pass
 
3974
            self.target.add_revision(revision.revision_id, revision)
 
3975
        return basis_id
 
3976
 
 
3977
    def _fetch_all_revisions(self, revision_ids, pb):
 
3978
        """Fetch everything for the list of revisions.
 
3979
 
 
3980
        :param revision_ids: The list of revisions to fetch. Must be in
 
3981
            topological order.
 
3982
        :param pb: A ProgressTask
 
3983
        :return: None
 
3984
        """
 
3985
        basis_id, basis_tree = self._get_basis(revision_ids[0])
 
3986
        batch_size = 100
 
3987
        cache = lru_cache.LRUCache(100)
 
3988
        cache[basis_id] = basis_tree
 
3989
        del basis_tree # We don't want to hang on to it here
 
3990
        hints = []
 
3991
        a_graph = None
 
3992
 
 
3993
        for offset in range(0, len(revision_ids), batch_size):
 
3994
            self.target.start_write_group()
 
3995
            try:
 
3996
                pb.update('Transferring revisions', offset,
 
3997
                          len(revision_ids))
 
3998
                batch = revision_ids[offset:offset+batch_size]
 
3999
                basis_id = self._fetch_batch(batch, basis_id, cache)
 
4000
            except:
 
4001
                self.source._safe_to_return_from_cache = False
 
4002
                self.target.abort_write_group()
 
4003
                raise
 
4004
            else:
 
4005
                hint = self.target.commit_write_group()
 
4006
                if hint:
 
4007
                    hints.extend(hint)
 
4008
        if hints and self.target._format.pack_compresses:
 
4009
            self.target.pack(hint=hints)
 
4010
        pb.update('Transferring revisions', len(revision_ids),
 
4011
                  len(revision_ids))
 
4012
 
 
4013
    @needs_write_lock
 
4014
    def fetch(self, revision_id=None, pb=None, find_ghosts=False,
 
4015
            fetch_spec=None):
 
4016
        """See InterRepository.fetch()."""
 
4017
        if fetch_spec is not None:
 
4018
            raise AssertionError("Not implemented yet...")
 
4019
        ui.ui_factory.warn_experimental_format_fetch(self)
 
4020
        if (not self.source.supports_rich_root()
 
4021
            and self.target.supports_rich_root()):
 
4022
            self._converting_to_rich_root = True
 
4023
            self._revision_id_to_root_id = {}
 
4024
        else:
 
4025
            self._converting_to_rich_root = False
 
4026
        # See <https://launchpad.net/bugs/456077> asking for a warning here
 
4027
        if self.source._format.network_name() != self.target._format.network_name():
 
4028
            ui.ui_factory.show_user_warning('cross_format_fetch',
 
4029
                from_format=self.source._format,
 
4030
                to_format=self.target._format)
 
4031
        revision_ids = self.target.search_missing_revision_ids(self.source,
 
4032
            revision_id, find_ghosts=find_ghosts).get_keys()
 
4033
        if not revision_ids:
 
4034
            return 0, 0
 
4035
        revision_ids = tsort.topo_sort(
 
4036
            self.source.get_graph().get_parent_map(revision_ids))
 
4037
        if not revision_ids:
 
4038
            return 0, 0
 
4039
        # Walk though all revisions; get inventory deltas, copy referenced
 
4040
        # texts that delta references, insert the delta, revision and
 
4041
        # signature.
 
4042
        if pb is None:
 
4043
            my_pb = ui.ui_factory.nested_progress_bar()
 
4044
            pb = my_pb
 
4045
        else:
 
4046
            symbol_versioning.warn(
 
4047
                symbol_versioning.deprecated_in((1, 14, 0))
 
4048
                % "pb parameter to fetch()")
 
4049
            my_pb = None
 
4050
        try:
 
4051
            self._fetch_all_revisions(revision_ids, pb)
 
4052
        finally:
 
4053
            if my_pb is not None:
 
4054
                my_pb.finished()
 
4055
        return len(revision_ids), 0
 
4056
 
 
4057
    def _get_basis(self, first_revision_id):
 
4058
        """Get a revision and tree which exists in the target.
 
4059
 
 
4060
        This assumes that first_revision_id is selected for transmission
 
4061
        because all other ancestors are already present. If we can't find an
 
4062
        ancestor we fall back to NULL_REVISION since we know that is safe.
 
4063
 
 
4064
        :return: (basis_id, basis_tree)
 
4065
        """
 
4066
        first_rev = self.source.get_revision(first_revision_id)
 
4067
        try:
 
4068
            basis_id = first_rev.parent_ids[0]
 
4069
            # only valid as a basis if the target has it
 
4070
            self.target.get_revision(basis_id)
 
4071
            # Try to get a basis tree - if it's a ghost it will hit the
 
4072
            # NoSuchRevision case.
 
4073
            basis_tree = self.source.revision_tree(basis_id)
 
4074
        except (IndexError, errors.NoSuchRevision):
 
4075
            basis_id = _mod_revision.NULL_REVISION
 
4076
            basis_tree = self.source.revision_tree(basis_id)
 
4077
        return basis_id, basis_tree
 
4078
 
 
4079
 
 
4080
InterRepository.register_optimiser(InterDifferingSerializer)
 
4081
InterRepository.register_optimiser(InterSameDataRepository)
1843
4082
InterRepository.register_optimiser(InterWeaveRepo)
1844
4083
InterRepository.register_optimiser(InterKnitRepo)
1845
4084
 
1846
4085
 
1847
 
class RepositoryTestProviderAdapter(object):
1848
 
    """A tool to generate a suite testing multiple repository formats at once.
1849
 
 
1850
 
    This is done by copying the test once for each transport and injecting
1851
 
    the transport_server, transport_readonly_server, and bzrdir_format and
1852
 
    repository_format classes into each copy. Each copy is also given a new id()
1853
 
    to make it easy to identify.
1854
 
    """
1855
 
 
1856
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1857
 
        self._transport_server = transport_server
1858
 
        self._transport_readonly_server = transport_readonly_server
1859
 
        self._formats = formats
1860
 
    
1861
 
    def adapt(self, test):
1862
 
        result = TestSuite()
1863
 
        for repository_format, bzrdir_format in self._formats:
1864
 
            new_test = deepcopy(test)
1865
 
            new_test.transport_server = self._transport_server
1866
 
            new_test.transport_readonly_server = self._transport_readonly_server
1867
 
            new_test.bzrdir_format = bzrdir_format
1868
 
            new_test.repository_format = repository_format
1869
 
            def make_new_test_id():
1870
 
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
1871
 
                return lambda: new_id
1872
 
            new_test.id = make_new_test_id()
1873
 
            result.addTest(new_test)
1874
 
        return result
1875
 
 
1876
 
 
1877
 
class InterRepositoryTestProviderAdapter(object):
1878
 
    """A tool to generate a suite testing multiple inter repository formats.
1879
 
 
1880
 
    This is done by copying the test once for each interrepo provider and injecting
1881
 
    the transport_server, transport_readonly_server, repository_format and 
1882
 
    repository_to_format classes into each copy.
1883
 
    Each copy is also given a new id() to make it easy to identify.
1884
 
    """
1885
 
 
1886
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1887
 
        self._transport_server = transport_server
1888
 
        self._transport_readonly_server = transport_readonly_server
1889
 
        self._formats = formats
1890
 
    
1891
 
    def adapt(self, test):
1892
 
        result = TestSuite()
1893
 
        for interrepo_class, repository_format, repository_format_to in self._formats:
1894
 
            new_test = deepcopy(test)
1895
 
            new_test.transport_server = self._transport_server
1896
 
            new_test.transport_readonly_server = self._transport_readonly_server
1897
 
            new_test.interrepo_class = interrepo_class
1898
 
            new_test.repository_format = repository_format
1899
 
            new_test.repository_format_to = repository_format_to
1900
 
            def make_new_test_id():
1901
 
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
1902
 
                return lambda: new_id
1903
 
            new_test.id = make_new_test_id()
1904
 
            result.addTest(new_test)
1905
 
        return result
1906
 
 
1907
 
    @staticmethod
1908
 
    def default_test_list():
1909
 
        """Generate the default list of interrepo permutations to test."""
1910
 
        result = []
1911
 
        # test the default InterRepository between format 6 and the current 
1912
 
        # default format.
1913
 
        # XXX: robertc 20060220 reinstate this when there are two supported
1914
 
        # formats which do not have an optimal code path between them.
1915
 
        result.append((InterRepository,
1916
 
                       RepositoryFormat6(),
1917
 
                       RepositoryFormatKnit1()))
1918
 
        for optimiser in InterRepository._optimisers:
1919
 
            result.append((optimiser,
1920
 
                           optimiser._matching_repo_format,
1921
 
                           optimiser._matching_repo_format
1922
 
                           ))
1923
 
        # if there are specific combinations we want to use, we can add them 
1924
 
        # here.
1925
 
        return result
1926
 
 
1927
 
 
1928
4086
class CopyConverter(object):
1929
4087
    """A repository conversion tool which just performs a copy of the content.
1930
 
    
 
4088
 
1931
4089
    This is slow but quite reliable.
1932
4090
    """
1933
4091
 
1937
4095
        :param target_format: The format the resulting repository should be.
1938
4096
        """
1939
4097
        self.target_format = target_format
1940
 
        
 
4098
 
1941
4099
    def convert(self, repo, pb):
1942
4100
        """Perform the conversion of to_convert, giving feedback via pb.
1943
4101
 
1944
4102
        :param to_convert: The disk object to convert.
1945
4103
        :param pb: a progress bar to use for progress information.
1946
4104
        """
1947
 
        self.pb = pb
 
4105
        pb = ui.ui_factory.nested_progress_bar()
1948
4106
        self.count = 0
1949
4107
        self.total = 4
1950
4108
        # this is only useful with metadir layouts - separated repo content.
1951
4109
        # trigger an assertion if not such
1952
4110
        repo._format.get_format_string()
1953
4111
        self.repo_dir = repo.bzrdir
1954
 
        self.step('Moving repository to repository.backup')
 
4112
        pb.update('Moving repository to repository.backup')
1955
4113
        self.repo_dir.transport.move('repository', 'repository.backup')
1956
4114
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
 
4115
        repo._format.check_conversion_target(self.target_format)
1957
4116
        self.source_repo = repo._format.open(self.repo_dir,
1958
4117
            _found=True,
1959
4118
            _override_transport=backup_transport)
1960
 
        self.step('Creating new repository')
 
4119
        pb.update('Creating new repository')
1961
4120
        converted = self.target_format.initialize(self.repo_dir,
1962
4121
                                                  self.source_repo.is_shared())
1963
4122
        converted.lock_write()
1964
4123
        try:
1965
 
            self.step('Copying content into repository.')
 
4124
            pb.update('Copying content')
1966
4125
            self.source_repo.copy_content_into(converted)
1967
4126
        finally:
1968
4127
            converted.unlock()
1969
 
        self.step('Deleting old repository content.')
 
4128
        pb.update('Deleting old repository content')
1970
4129
        self.repo_dir.transport.delete_tree('repository.backup')
1971
 
        self.pb.note('repository converted')
1972
 
 
1973
 
    def step(self, message):
1974
 
        """Update the pb by a step."""
1975
 
        self.count +=1
1976
 
        self.pb.update(message, self.count, self.total)
1977
 
 
1978
 
 
1979
 
class CommitBuilder(object):
1980
 
    """Provides an interface to build up a commit.
1981
 
 
1982
 
    This allows describing a tree to be committed without needing to 
1983
 
    know the internals of the format of the repository.
1984
 
    """
1985
 
    def __init__(self, repository, parents, config, timestamp=None, 
1986
 
                 timezone=None, committer=None, revprops=None, 
1987
 
                 revision_id=None):
1988
 
        """Initiate a CommitBuilder.
1989
 
 
1990
 
        :param repository: Repository to commit to.
1991
 
        :param parents: Revision ids of the parents of the new revision.
1992
 
        :param config: Configuration to use.
1993
 
        :param timestamp: Optional timestamp recorded for commit.
1994
 
        :param timezone: Optional timezone for timestamp.
1995
 
        :param committer: Optional committer to set for commit.
1996
 
        :param revprops: Optional dictionary of revision properties.
1997
 
        :param revision_id: Optional revision id.
1998
 
        """
1999
 
        self._config = config
2000
 
 
2001
 
        if committer is None:
2002
 
            self._committer = self._config.username()
2003
 
        else:
2004
 
            assert isinstance(committer, basestring), type(committer)
2005
 
            self._committer = committer
2006
 
 
2007
 
        self.new_inventory = Inventory()
2008
 
        self._new_revision_id = revision_id
2009
 
        self.parents = parents
2010
 
        self.repository = repository
2011
 
 
2012
 
        self._revprops = {}
2013
 
        if revprops is not None:
2014
 
            self._revprops.update(revprops)
2015
 
 
2016
 
        if timestamp is None:
2017
 
            self._timestamp = time.time()
2018
 
        else:
2019
 
            self._timestamp = long(timestamp)
2020
 
 
2021
 
        if timezone is None:
2022
 
            self._timezone = local_time_offset()
2023
 
        else:
2024
 
            self._timezone = int(timezone)
2025
 
 
2026
 
        self._generate_revision_if_needed()
2027
 
 
2028
 
    def commit(self, message):
2029
 
        """Make the actual commit.
2030
 
 
2031
 
        :return: The revision id of the recorded revision.
2032
 
        """
2033
 
        rev = Revision(timestamp=self._timestamp,
2034
 
                       timezone=self._timezone,
2035
 
                       committer=self._committer,
2036
 
                       message=message,
2037
 
                       inventory_sha1=self.inv_sha1,
2038
 
                       revision_id=self._new_revision_id,
2039
 
                       properties=self._revprops)
2040
 
        rev.parent_ids = self.parents
2041
 
        self.repository.add_revision(self._new_revision_id, rev, 
2042
 
            self.new_inventory, self._config)
2043
 
        return self._new_revision_id
2044
 
 
2045
 
    def finish_inventory(self):
2046
 
        """Tell the builder that the inventory is finished."""
2047
 
        self.new_inventory.revision_id = self._new_revision_id
2048
 
        self.inv_sha1 = self.repository.add_inventory(
2049
 
            self._new_revision_id,
2050
 
            self.new_inventory,
2051
 
            self.parents
2052
 
            )
2053
 
 
2054
 
    def _gen_revision_id(self):
2055
 
        """Return new revision-id."""
2056
 
        s = '%s-%s-' % (self._config.user_email(), 
2057
 
                        compact_date(self._timestamp))
2058
 
        s += hexlify(rand_bytes(8))
2059
 
        return s
2060
 
 
2061
 
    def _generate_revision_if_needed(self):
2062
 
        """Create a revision id if None was supplied.
2063
 
        
2064
 
        If the repository can not support user-specified revision ids
2065
 
        they should override this function and raise UnsupportedOperation
2066
 
        if _new_revision_id is not None.
2067
 
 
2068
 
        :raises: UnsupportedOperation
2069
 
        """
2070
 
        if self._new_revision_id is None:
2071
 
            self._new_revision_id = self._gen_revision_id()
2072
 
 
2073
 
    def record_entry_contents(self, ie, parent_invs, path, tree):
2074
 
        """Record the content of ie from tree into the commit if needed.
2075
 
 
2076
 
        :param ie: An inventory entry present in the commit.
2077
 
        :param parent_invs: The inventories of the parent revisions of the
2078
 
            commit.
2079
 
        :param path: The path the entry is at in the tree.
2080
 
        :param tree: The tree which contains this entry and should be used to 
2081
 
        obtain content.
2082
 
        """
2083
 
        self.new_inventory.add(ie)
2084
 
 
2085
 
        # ie.revision is always None if the InventoryEntry is considered
2086
 
        # for committing. ie.snapshot will record the correct revision 
2087
 
        # which may be the sole parent if it is untouched.
2088
 
        if ie.revision is not None:
2089
 
            return
2090
 
        previous_entries = ie.find_previous_heads(
2091
 
            parent_invs,
2092
 
            self.repository.weave_store,
2093
 
            self.repository.get_transaction())
2094
 
        # we are creating a new revision for ie in the history store
2095
 
        # and inventory.
2096
 
        ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
2097
 
 
2098
 
    def modified_directory(self, file_id, file_parents):
2099
 
        """Record the presence of a symbolic link.
2100
 
 
2101
 
        :param file_id: The file_id of the link to record.
2102
 
        :param file_parents: The per-file parent revision ids.
2103
 
        """
2104
 
        self._add_text_to_weave(file_id, [], file_parents.keys())
2105
 
    
2106
 
    def modified_file_text(self, file_id, file_parents,
2107
 
                           get_content_byte_lines, text_sha1=None,
2108
 
                           text_size=None):
2109
 
        """Record the text of file file_id
2110
 
 
2111
 
        :param file_id: The file_id of the file to record the text of.
2112
 
        :param file_parents: The per-file parent revision ids.
2113
 
        :param get_content_byte_lines: A callable which will return the byte
2114
 
            lines for the file.
2115
 
        :param text_sha1: Optional SHA1 of the file contents.
2116
 
        :param text_size: Optional size of the file contents.
2117
 
        """
2118
 
        mutter('storing text of file {%s} in revision {%s} into %r',
2119
 
               file_id, self._new_revision_id, self.repository.weave_store)
2120
 
        # special case to avoid diffing on renames or 
2121
 
        # reparenting
2122
 
        if (len(file_parents) == 1
2123
 
            and text_sha1 == file_parents.values()[0].text_sha1
2124
 
            and text_size == file_parents.values()[0].text_size):
2125
 
            previous_ie = file_parents.values()[0]
2126
 
            versionedfile = self.repository.weave_store.get_weave(file_id, 
2127
 
                self.repository.get_transaction())
2128
 
            versionedfile.clone_text(self._new_revision_id, 
2129
 
                previous_ie.revision, file_parents.keys())
2130
 
            return text_sha1, text_size
2131
 
        else:
2132
 
            new_lines = get_content_byte_lines()
2133
 
            # TODO: Rather than invoking sha_strings here, _add_text_to_weave
2134
 
            # should return the SHA1 and size
2135
 
            self._add_text_to_weave(file_id, new_lines, file_parents.keys())
2136
 
            return osutils.sha_strings(new_lines), \
2137
 
                sum(map(len, new_lines))
2138
 
 
2139
 
    def modified_link(self, file_id, file_parents, link_target):
2140
 
        """Record the presence of a symbolic link.
2141
 
 
2142
 
        :param file_id: The file_id of the link to record.
2143
 
        :param file_parents: The per-file parent revision ids.
2144
 
        :param link_target: Target location of this link.
2145
 
        """
2146
 
        self._add_text_to_weave(file_id, [], file_parents.keys())
2147
 
 
2148
 
    def _add_text_to_weave(self, file_id, new_lines, parents):
2149
 
        versionedfile = self.repository.weave_store.get_weave_or_empty(
2150
 
            file_id, self.repository.get_transaction())
2151
 
        versionedfile.add_lines(self._new_revision_id, parents, new_lines)
2152
 
        versionedfile.clear_cache()
 
4130
        ui.ui_factory.note('repository converted')
 
4131
        pb.finished()
2153
4132
 
2154
4133
 
2155
4134
_unescape_map = {
2162
4141
 
2163
4142
 
2164
4143
def _unescaper(match, _map=_unescape_map):
2165
 
    return _map[match.group(1)]
 
4144
    code = match.group(1)
 
4145
    try:
 
4146
        return _map[code]
 
4147
    except KeyError:
 
4148
        if not code.startswith('#'):
 
4149
            raise
 
4150
        return unichr(int(code[1:])).encode('utf8')
2166
4151
 
2167
4152
 
2168
4153
_unescape_re = None
2172
4157
    """Unescape predefined XML entities in a string of data."""
2173
4158
    global _unescape_re
2174
4159
    if _unescape_re is None:
2175
 
        _unescape_re = re.compile('\&([^;]*);')
 
4160
        _unescape_re = re.compile('\&([^;]*);')
2176
4161
    return _unescape_re.sub(_unescaper, data)
 
4162
 
 
4163
 
 
4164
class _VersionedFileChecker(object):
 
4165
 
 
4166
    def __init__(self, repository, text_key_references=None, ancestors=None):
 
4167
        self.repository = repository
 
4168
        self.text_index = self.repository._generate_text_key_index(
 
4169
            text_key_references=text_key_references, ancestors=ancestors)
 
4170
 
 
4171
    def calculate_file_version_parents(self, text_key):
 
4172
        """Calculate the correct parents for a file version according to
 
4173
        the inventories.
 
4174
        """
 
4175
        parent_keys = self.text_index[text_key]
 
4176
        if parent_keys == [_mod_revision.NULL_REVISION]:
 
4177
            return ()
 
4178
        return tuple(parent_keys)
 
4179
 
 
4180
    def check_file_version_parents(self, texts, progress_bar=None):
 
4181
        """Check the parents stored in a versioned file are correct.
 
4182
 
 
4183
        It also detects file versions that are not referenced by their
 
4184
        corresponding revision's inventory.
 
4185
 
 
4186
        :returns: A tuple of (wrong_parents, dangling_file_versions).
 
4187
            wrong_parents is a dict mapping {revision_id: (stored_parents,
 
4188
            correct_parents)} for each revision_id where the stored parents
 
4189
            are not correct.  dangling_file_versions is a set of (file_id,
 
4190
            revision_id) tuples for versions that are present in this versioned
 
4191
            file, but not used by the corresponding inventory.
 
4192
        """
 
4193
        local_progress = None
 
4194
        if progress_bar is None:
 
4195
            local_progress = ui.ui_factory.nested_progress_bar()
 
4196
            progress_bar = local_progress
 
4197
        try:
 
4198
            return self._check_file_version_parents(texts, progress_bar)
 
4199
        finally:
 
4200
            if local_progress:
 
4201
                local_progress.finished()
 
4202
 
 
4203
    def _check_file_version_parents(self, texts, progress_bar):
 
4204
        """See check_file_version_parents."""
 
4205
        wrong_parents = {}
 
4206
        self.file_ids = set([file_id for file_id, _ in
 
4207
            self.text_index.iterkeys()])
 
4208
        # text keys is now grouped by file_id
 
4209
        n_versions = len(self.text_index)
 
4210
        progress_bar.update('loading text store', 0, n_versions)
 
4211
        parent_map = self.repository.texts.get_parent_map(self.text_index)
 
4212
        # On unlistable transports this could well be empty/error...
 
4213
        text_keys = self.repository.texts.keys()
 
4214
        unused_keys = frozenset(text_keys) - set(self.text_index)
 
4215
        for num, key in enumerate(self.text_index.iterkeys()):
 
4216
            progress_bar.update('checking text graph', num, n_versions)
 
4217
            correct_parents = self.calculate_file_version_parents(key)
 
4218
            try:
 
4219
                knit_parents = parent_map[key]
 
4220
            except errors.RevisionNotPresent:
 
4221
                # Missing text!
 
4222
                knit_parents = None
 
4223
            if correct_parents != knit_parents:
 
4224
                wrong_parents[key] = (knit_parents, correct_parents)
 
4225
        return wrong_parents, unused_keys
 
4226
 
 
4227
 
 
4228
def _old_get_graph(repository, revision_id):
 
4229
    """DO NOT USE. That is all. I'm serious."""
 
4230
    graph = repository.get_graph()
 
4231
    revision_graph = dict(((key, value) for key, value in
 
4232
        graph.iter_ancestry([revision_id]) if value is not None))
 
4233
    return _strip_NULL_ghosts(revision_graph)
 
4234
 
 
4235
 
 
4236
def _strip_NULL_ghosts(revision_graph):
 
4237
    """Also don't use this. more compatibility code for unmigrated clients."""
 
4238
    # Filter ghosts, and null:
 
4239
    if _mod_revision.NULL_REVISION in revision_graph:
 
4240
        del revision_graph[_mod_revision.NULL_REVISION]
 
4241
    for key, parents in revision_graph.items():
 
4242
        revision_graph[key] = tuple(parent for parent in parents if parent
 
4243
            in revision_graph)
 
4244
    return revision_graph
 
4245
 
 
4246
 
 
4247
class StreamSink(object):
 
4248
    """An object that can insert a stream into a repository.
 
4249
 
 
4250
    This interface handles the complexity of reserialising inventories and
 
4251
    revisions from different formats, and allows unidirectional insertion into
 
4252
    stacked repositories without looking for the missing basis parents
 
4253
    beforehand.
 
4254
    """
 
4255
 
 
4256
    def __init__(self, target_repo):
 
4257
        self.target_repo = target_repo
 
4258
 
 
4259
    def insert_stream(self, stream, src_format, resume_tokens):
 
4260
        """Insert a stream's content into the target repository.
 
4261
 
 
4262
        :param src_format: a bzr repository format.
 
4263
 
 
4264
        :return: a list of resume tokens and an  iterable of keys additional
 
4265
            items required before the insertion can be completed.
 
4266
        """
 
4267
        self.target_repo.lock_write()
 
4268
        try:
 
4269
            if resume_tokens:
 
4270
                self.target_repo.resume_write_group(resume_tokens)
 
4271
                is_resume = True
 
4272
            else:
 
4273
                self.target_repo.start_write_group()
 
4274
                is_resume = False
 
4275
            try:
 
4276
                # locked_insert_stream performs a commit|suspend.
 
4277
                return self._locked_insert_stream(stream, src_format,
 
4278
                    is_resume)
 
4279
            except:
 
4280
                self.target_repo.abort_write_group(suppress_errors=True)
 
4281
                raise
 
4282
        finally:
 
4283
            self.target_repo.unlock()
 
4284
 
 
4285
    def _locked_insert_stream(self, stream, src_format, is_resume):
 
4286
        to_serializer = self.target_repo._format._serializer
 
4287
        src_serializer = src_format._serializer
 
4288
        new_pack = None
 
4289
        if to_serializer == src_serializer:
 
4290
            # If serializers match and the target is a pack repository, set the
 
4291
            # write cache size on the new pack.  This avoids poor performance
 
4292
            # on transports where append is unbuffered (such as
 
4293
            # RemoteTransport).  This is safe to do because nothing should read
 
4294
            # back from the target repository while a stream with matching
 
4295
            # serialization is being inserted.
 
4296
            # The exception is that a delta record from the source that should
 
4297
            # be a fulltext may need to be expanded by the target (see
 
4298
            # test_fetch_revisions_with_deltas_into_pack); but we take care to
 
4299
            # explicitly flush any buffered writes first in that rare case.
 
4300
            try:
 
4301
                new_pack = self.target_repo._pack_collection._new_pack
 
4302
            except AttributeError:
 
4303
                # Not a pack repository
 
4304
                pass
 
4305
            else:
 
4306
                new_pack.set_write_cache_size(1024*1024)
 
4307
        for substream_type, substream in stream:
 
4308
            if 'stream' in debug.debug_flags:
 
4309
                mutter('inserting substream: %s', substream_type)
 
4310
            if substream_type == 'texts':
 
4311
                self.target_repo.texts.insert_record_stream(substream)
 
4312
            elif substream_type == 'inventories':
 
4313
                if src_serializer == to_serializer:
 
4314
                    self.target_repo.inventories.insert_record_stream(
 
4315
                        substream)
 
4316
                else:
 
4317
                    self._extract_and_insert_inventories(
 
4318
                        substream, src_serializer)
 
4319
            elif substream_type == 'inventory-deltas':
 
4320
                self._extract_and_insert_inventory_deltas(
 
4321
                    substream, src_serializer)
 
4322
            elif substream_type == 'chk_bytes':
 
4323
                # XXX: This doesn't support conversions, as it assumes the
 
4324
                #      conversion was done in the fetch code.
 
4325
                self.target_repo.chk_bytes.insert_record_stream(substream)
 
4326
            elif substream_type == 'revisions':
 
4327
                # This may fallback to extract-and-insert more often than
 
4328
                # required if the serializers are different only in terms of
 
4329
                # the inventory.
 
4330
                if src_serializer == to_serializer:
 
4331
                    self.target_repo.revisions.insert_record_stream(substream)
 
4332
                else:
 
4333
                    self._extract_and_insert_revisions(substream,
 
4334
                        src_serializer)
 
4335
            elif substream_type == 'signatures':
 
4336
                self.target_repo.signatures.insert_record_stream(substream)
 
4337
            else:
 
4338
                raise AssertionError('kaboom! %s' % (substream_type,))
 
4339
        # Done inserting data, and the missing_keys calculations will try to
 
4340
        # read back from the inserted data, so flush the writes to the new pack
 
4341
        # (if this is pack format).
 
4342
        if new_pack is not None:
 
4343
            new_pack._write_data('', flush=True)
 
4344
        # Find all the new revisions (including ones from resume_tokens)
 
4345
        missing_keys = self.target_repo.get_missing_parent_inventories(
 
4346
            check_for_missing_texts=is_resume)
 
4347
        try:
 
4348
            for prefix, versioned_file in (
 
4349
                ('texts', self.target_repo.texts),
 
4350
                ('inventories', self.target_repo.inventories),
 
4351
                ('revisions', self.target_repo.revisions),
 
4352
                ('signatures', self.target_repo.signatures),
 
4353
                ('chk_bytes', self.target_repo.chk_bytes),
 
4354
                ):
 
4355
                if versioned_file is None:
 
4356
                    continue
 
4357
                # TODO: key is often going to be a StaticTuple object
 
4358
                #       I don't believe we can define a method by which
 
4359
                #       (prefix,) + StaticTuple will work, though we could
 
4360
                #       define a StaticTuple.sq_concat that would allow you to
 
4361
                #       pass in either a tuple or a StaticTuple as the second
 
4362
                #       object, so instead we could have:
 
4363
                #       StaticTuple(prefix) + key here...
 
4364
                missing_keys.update((prefix,) + key for key in
 
4365
                    versioned_file.get_missing_compression_parent_keys())
 
4366
        except NotImplementedError:
 
4367
            # cannot even attempt suspending, and missing would have failed
 
4368
            # during stream insertion.
 
4369
            missing_keys = set()
 
4370
        else:
 
4371
            if missing_keys:
 
4372
                # suspend the write group and tell the caller what we is
 
4373
                # missing. We know we can suspend or else we would not have
 
4374
                # entered this code path. (All repositories that can handle
 
4375
                # missing keys can handle suspending a write group).
 
4376
                write_group_tokens = self.target_repo.suspend_write_group()
 
4377
                return write_group_tokens, missing_keys
 
4378
        hint = self.target_repo.commit_write_group()
 
4379
        if (to_serializer != src_serializer and
 
4380
            self.target_repo._format.pack_compresses):
 
4381
            self.target_repo.pack(hint=hint)
 
4382
        return [], set()
 
4383
 
 
4384
    def _extract_and_insert_inventory_deltas(self, substream, serializer):
 
4385
        target_rich_root = self.target_repo._format.rich_root_data
 
4386
        target_tree_refs = self.target_repo._format.supports_tree_reference
 
4387
        for record in substream:
 
4388
            # Insert the delta directly
 
4389
            inventory_delta_bytes = record.get_bytes_as('fulltext')
 
4390
            deserialiser = inventory_delta.InventoryDeltaDeserializer()
 
4391
            try:
 
4392
                parse_result = deserialiser.parse_text_bytes(
 
4393
                    inventory_delta_bytes)
 
4394
            except inventory_delta.IncompatibleInventoryDelta, err:
 
4395
                trace.mutter("Incompatible delta: %s", err.msg)
 
4396
                raise errors.IncompatibleRevision(self.target_repo._format)
 
4397
            basis_id, new_id, rich_root, tree_refs, inv_delta = parse_result
 
4398
            revision_id = new_id
 
4399
            parents = [key[0] for key in record.parents]
 
4400
            self.target_repo.add_inventory_by_delta(
 
4401
                basis_id, inv_delta, revision_id, parents)
 
4402
 
 
4403
    def _extract_and_insert_inventories(self, substream, serializer,
 
4404
            parse_delta=None):
 
4405
        """Generate a new inventory versionedfile in target, converting data.
 
4406
 
 
4407
        The inventory is retrieved from the source, (deserializing it), and
 
4408
        stored in the target (reserializing it in a different format).
 
4409
        """
 
4410
        target_rich_root = self.target_repo._format.rich_root_data
 
4411
        target_tree_refs = self.target_repo._format.supports_tree_reference
 
4412
        for record in substream:
 
4413
            # It's not a delta, so it must be a fulltext in the source
 
4414
            # serializer's format.
 
4415
            bytes = record.get_bytes_as('fulltext')
 
4416
            revision_id = record.key[0]
 
4417
            inv = serializer.read_inventory_from_string(bytes, revision_id)
 
4418
            parents = [key[0] for key in record.parents]
 
4419
            self.target_repo.add_inventory(revision_id, inv, parents)
 
4420
            # No need to keep holding this full inv in memory when the rest of
 
4421
            # the substream is likely to be all deltas.
 
4422
            del inv
 
4423
 
 
4424
    def _extract_and_insert_revisions(self, substream, serializer):
 
4425
        for record in substream:
 
4426
            bytes = record.get_bytes_as('fulltext')
 
4427
            revision_id = record.key[0]
 
4428
            rev = serializer.read_revision_from_string(bytes)
 
4429
            if rev.revision_id != revision_id:
 
4430
                raise AssertionError('wtf: %s != %s' % (rev, revision_id))
 
4431
            self.target_repo.add_revision(revision_id, rev)
 
4432
 
 
4433
    def finished(self):
 
4434
        if self.target_repo._format._fetch_reconcile:
 
4435
            self.target_repo.reconcile()
 
4436
 
 
4437
 
 
4438
class StreamSource(object):
 
4439
    """A source of a stream for fetching between repositories."""
 
4440
 
 
4441
    def __init__(self, from_repository, to_format):
 
4442
        """Create a StreamSource streaming from from_repository."""
 
4443
        self.from_repository = from_repository
 
4444
        self.to_format = to_format
 
4445
        self._record_counter = RecordCounter()
 
4446
 
 
4447
    def delta_on_metadata(self):
 
4448
        """Return True if delta's are permitted on metadata streams.
 
4449
 
 
4450
        That is on revisions and signatures.
 
4451
        """
 
4452
        src_serializer = self.from_repository._format._serializer
 
4453
        target_serializer = self.to_format._serializer
 
4454
        return (self.to_format._fetch_uses_deltas and
 
4455
            src_serializer == target_serializer)
 
4456
 
 
4457
    def _fetch_revision_texts(self, revs):
 
4458
        # fetch signatures first and then the revision texts
 
4459
        # may need to be a InterRevisionStore call here.
 
4460
        from_sf = self.from_repository.signatures
 
4461
        # A missing signature is just skipped.
 
4462
        keys = [(rev_id,) for rev_id in revs]
 
4463
        signatures = versionedfile.filter_absent(from_sf.get_record_stream(
 
4464
            keys,
 
4465
            self.to_format._fetch_order,
 
4466
            not self.to_format._fetch_uses_deltas))
 
4467
        # If a revision has a delta, this is actually expanded inside the
 
4468
        # insert_record_stream code now, which is an alternate fix for
 
4469
        # bug #261339
 
4470
        from_rf = self.from_repository.revisions
 
4471
        revisions = from_rf.get_record_stream(
 
4472
            keys,
 
4473
            self.to_format._fetch_order,
 
4474
            not self.delta_on_metadata())
 
4475
        return [('signatures', signatures), ('revisions', revisions)]
 
4476
 
 
4477
    def _generate_root_texts(self, revs):
 
4478
        """This will be called by get_stream between fetching weave texts and
 
4479
        fetching the inventory weave.
 
4480
        """
 
4481
        if self._rich_root_upgrade():
 
4482
            return _mod_fetch.Inter1and2Helper(
 
4483
                self.from_repository).generate_root_texts(revs)
 
4484
        else:
 
4485
            return []
 
4486
 
 
4487
    def get_stream(self, search):
 
4488
        phase = 'file'
 
4489
        revs = search.get_keys()
 
4490
        graph = self.from_repository.get_graph()
 
4491
        revs = tsort.topo_sort(graph.get_parent_map(revs))
 
4492
        data_to_fetch = self.from_repository.item_keys_introduced_by(revs)
 
4493
        text_keys = []
 
4494
        for knit_kind, file_id, revisions in data_to_fetch:
 
4495
            if knit_kind != phase:
 
4496
                phase = knit_kind
 
4497
                # Make a new progress bar for this phase
 
4498
            if knit_kind == "file":
 
4499
                # Accumulate file texts
 
4500
                text_keys.extend([(file_id, revision) for revision in
 
4501
                    revisions])
 
4502
            elif knit_kind == "inventory":
 
4503
                # Now copy the file texts.
 
4504
                from_texts = self.from_repository.texts
 
4505
                yield ('texts', from_texts.get_record_stream(
 
4506
                    text_keys, self.to_format._fetch_order,
 
4507
                    not self.to_format._fetch_uses_deltas))
 
4508
                # Cause an error if a text occurs after we have done the
 
4509
                # copy.
 
4510
                text_keys = None
 
4511
                # Before we process the inventory we generate the root
 
4512
                # texts (if necessary) so that the inventories references
 
4513
                # will be valid.
 
4514
                for _ in self._generate_root_texts(revs):
 
4515
                    yield _
 
4516
                # we fetch only the referenced inventories because we do not
 
4517
                # know for unselected inventories whether all their required
 
4518
                # texts are present in the other repository - it could be
 
4519
                # corrupt.
 
4520
                for info in self._get_inventory_stream(revs):
 
4521
                    yield info
 
4522
            elif knit_kind == "signatures":
 
4523
                # Nothing to do here; this will be taken care of when
 
4524
                # _fetch_revision_texts happens.
 
4525
                pass
 
4526
            elif knit_kind == "revisions":
 
4527
                for record in self._fetch_revision_texts(revs):
 
4528
                    yield record
 
4529
            else:
 
4530
                raise AssertionError("Unknown knit kind %r" % knit_kind)
 
4531
 
 
4532
    def get_stream_for_missing_keys(self, missing_keys):
 
4533
        # missing keys can only occur when we are byte copying and not
 
4534
        # translating (because translation means we don't send
 
4535
        # unreconstructable deltas ever).
 
4536
        keys = {}
 
4537
        keys['texts'] = set()
 
4538
        keys['revisions'] = set()
 
4539
        keys['inventories'] = set()
 
4540
        keys['chk_bytes'] = set()
 
4541
        keys['signatures'] = set()
 
4542
        for key in missing_keys:
 
4543
            keys[key[0]].add(key[1:])
 
4544
        if len(keys['revisions']):
 
4545
            # If we allowed copying revisions at this point, we could end up
 
4546
            # copying a revision without copying its required texts: a
 
4547
            # violation of the requirements for repository integrity.
 
4548
            raise AssertionError(
 
4549
                'cannot copy revisions to fill in missing deltas %s' % (
 
4550
                    keys['revisions'],))
 
4551
        for substream_kind, keys in keys.iteritems():
 
4552
            vf = getattr(self.from_repository, substream_kind)
 
4553
            if vf is None and keys:
 
4554
                    raise AssertionError(
 
4555
                        "cannot fill in keys for a versioned file we don't"
 
4556
                        " have: %s needs %s" % (substream_kind, keys))
 
4557
            if not keys:
 
4558
                # No need to stream something we don't have
 
4559
                continue
 
4560
            if substream_kind == 'inventories':
 
4561
                # Some missing keys are genuinely ghosts, filter those out.
 
4562
                present = self.from_repository.inventories.get_parent_map(keys)
 
4563
                revs = [key[0] for key in present]
 
4564
                # Get the inventory stream more-or-less as we do for the
 
4565
                # original stream; there's no reason to assume that records
 
4566
                # direct from the source will be suitable for the sink.  (Think
 
4567
                # e.g. 2a -> 1.9-rich-root).
 
4568
                for info in self._get_inventory_stream(revs, missing=True):
 
4569
                    yield info
 
4570
                continue
 
4571
 
 
4572
            # Ask for full texts always so that we don't need more round trips
 
4573
            # after this stream.
 
4574
            # Some of the missing keys are genuinely ghosts, so filter absent
 
4575
            # records. The Sink is responsible for doing another check to
 
4576
            # ensure that ghosts don't introduce missing data for future
 
4577
            # fetches.
 
4578
            stream = versionedfile.filter_absent(vf.get_record_stream(keys,
 
4579
                self.to_format._fetch_order, True))
 
4580
            yield substream_kind, stream
 
4581
 
 
4582
    def inventory_fetch_order(self):
 
4583
        if self._rich_root_upgrade():
 
4584
            return 'topological'
 
4585
        else:
 
4586
            return self.to_format._fetch_order
 
4587
 
 
4588
    def _rich_root_upgrade(self):
 
4589
        return (not self.from_repository._format.rich_root_data and
 
4590
            self.to_format.rich_root_data)
 
4591
 
 
4592
    def _get_inventory_stream(self, revision_ids, missing=False):
 
4593
        from_format = self.from_repository._format
 
4594
        if (from_format.supports_chks and self.to_format.supports_chks and
 
4595
            from_format.network_name() == self.to_format.network_name()):
 
4596
            raise AssertionError(
 
4597
                "this case should be handled by GroupCHKStreamSource")
 
4598
        elif 'forceinvdeltas' in debug.debug_flags:
 
4599
            return self._get_convertable_inventory_stream(revision_ids,
 
4600
                    delta_versus_null=missing)
 
4601
        elif from_format.network_name() == self.to_format.network_name():
 
4602
            # Same format.
 
4603
            return self._get_simple_inventory_stream(revision_ids,
 
4604
                    missing=missing)
 
4605
        elif (not from_format.supports_chks and not self.to_format.supports_chks
 
4606
                and from_format._serializer == self.to_format._serializer):
 
4607
            # Essentially the same format.
 
4608
            return self._get_simple_inventory_stream(revision_ids,
 
4609
                    missing=missing)
 
4610
        else:
 
4611
            # Any time we switch serializations, we want to use an
 
4612
            # inventory-delta based approach.
 
4613
            return self._get_convertable_inventory_stream(revision_ids,
 
4614
                    delta_versus_null=missing)
 
4615
 
 
4616
    def _get_simple_inventory_stream(self, revision_ids, missing=False):
 
4617
        # NB: This currently reopens the inventory weave in source;
 
4618
        # using a single stream interface instead would avoid this.
 
4619
        from_weave = self.from_repository.inventories
 
4620
        if missing:
 
4621
            delta_closure = True
 
4622
        else:
 
4623
            delta_closure = not self.delta_on_metadata()
 
4624
        yield ('inventories', from_weave.get_record_stream(
 
4625
            [(rev_id,) for rev_id in revision_ids],
 
4626
            self.inventory_fetch_order(), delta_closure))
 
4627
 
 
4628
    def _get_convertable_inventory_stream(self, revision_ids,
 
4629
                                          delta_versus_null=False):
 
4630
        # The two formats are sufficiently different that there is no fast
 
4631
        # path, so we need to send just inventorydeltas, which any
 
4632
        # sufficiently modern client can insert into any repository.
 
4633
        # The StreamSink code expects to be able to
 
4634
        # convert on the target, so we need to put bytes-on-the-wire that can
 
4635
        # be converted.  That means inventory deltas (if the remote is <1.19,
 
4636
        # RemoteStreamSink will fallback to VFS to insert the deltas).
 
4637
        yield ('inventory-deltas',
 
4638
           self._stream_invs_as_deltas(revision_ids,
 
4639
                                       delta_versus_null=delta_versus_null))
 
4640
 
 
4641
    def _stream_invs_as_deltas(self, revision_ids, delta_versus_null=False):
 
4642
        """Return a stream of inventory-deltas for the given rev ids.
 
4643
 
 
4644
        :param revision_ids: The list of inventories to transmit
 
4645
        :param delta_versus_null: Don't try to find a minimal delta for this
 
4646
            entry, instead compute the delta versus the NULL_REVISION. This
 
4647
            effectively streams a complete inventory. Used for stuff like
 
4648
            filling in missing parents, etc.
 
4649
        """
 
4650
        from_repo = self.from_repository
 
4651
        revision_keys = [(rev_id,) for rev_id in revision_ids]
 
4652
        parent_map = from_repo.inventories.get_parent_map(revision_keys)
 
4653
        # XXX: possibly repos could implement a more efficient iter_inv_deltas
 
4654
        # method...
 
4655
        inventories = self.from_repository.iter_inventories(
 
4656
            revision_ids, 'topological')
 
4657
        format = from_repo._format
 
4658
        invs_sent_so_far = set([_mod_revision.NULL_REVISION])
 
4659
        inventory_cache = lru_cache.LRUCache(50)
 
4660
        null_inventory = from_repo.revision_tree(
 
4661
            _mod_revision.NULL_REVISION).inventory
 
4662
        # XXX: ideally the rich-root/tree-refs flags would be per-revision, not
 
4663
        # per-repo (e.g.  streaming a non-rich-root revision out of a rich-root
 
4664
        # repo back into a non-rich-root repo ought to be allowed)
 
4665
        serializer = inventory_delta.InventoryDeltaSerializer(
 
4666
            versioned_root=format.rich_root_data,
 
4667
            tree_references=format.supports_tree_reference)
 
4668
        for inv in inventories:
 
4669
            key = (inv.revision_id,)
 
4670
            parent_keys = parent_map.get(key, ())
 
4671
            delta = None
 
4672
            if not delta_versus_null and parent_keys:
 
4673
                # The caller did not ask for complete inventories and we have
 
4674
                # some parents that we can delta against.  Make a delta against
 
4675
                # each parent so that we can find the smallest.
 
4676
                parent_ids = [parent_key[0] for parent_key in parent_keys]
 
4677
                for parent_id in parent_ids:
 
4678
                    if parent_id not in invs_sent_so_far:
 
4679
                        # We don't know that the remote side has this basis, so
 
4680
                        # we can't use it.
 
4681
                        continue
 
4682
                    if parent_id == _mod_revision.NULL_REVISION:
 
4683
                        parent_inv = null_inventory
 
4684
                    else:
 
4685
                        parent_inv = inventory_cache.get(parent_id, None)
 
4686
                        if parent_inv is None:
 
4687
                            parent_inv = from_repo.get_inventory(parent_id)
 
4688
                    candidate_delta = inv._make_delta(parent_inv)
 
4689
                    if (delta is None or
 
4690
                        len(delta) > len(candidate_delta)):
 
4691
                        delta = candidate_delta
 
4692
                        basis_id = parent_id
 
4693
            if delta is None:
 
4694
                # Either none of the parents ended up being suitable, or we
 
4695
                # were asked to delta against NULL
 
4696
                basis_id = _mod_revision.NULL_REVISION
 
4697
                delta = inv._make_delta(null_inventory)
 
4698
            invs_sent_so_far.add(inv.revision_id)
 
4699
            inventory_cache[inv.revision_id] = inv
 
4700
            delta_serialized = ''.join(
 
4701
                serializer.delta_to_lines(basis_id, key[-1], delta))
 
4702
            yield versionedfile.FulltextContentFactory(
 
4703
                key, parent_keys, None, delta_serialized)
 
4704
 
 
4705
 
 
4706
def _iter_for_revno(repo, partial_history_cache, stop_index=None,
 
4707
                    stop_revision=None):
 
4708
    """Extend the partial history to include a given index
 
4709
 
 
4710
    If a stop_index is supplied, stop when that index has been reached.
 
4711
    If a stop_revision is supplied, stop when that revision is
 
4712
    encountered.  Otherwise, stop when the beginning of history is
 
4713
    reached.
 
4714
 
 
4715
    :param stop_index: The index which should be present.  When it is
 
4716
        present, history extension will stop.
 
4717
    :param stop_revision: The revision id which should be present.  When
 
4718
        it is encountered, history extension will stop.
 
4719
    """
 
4720
    start_revision = partial_history_cache[-1]
 
4721
    iterator = repo.iter_reverse_revision_history(start_revision)
 
4722
    try:
 
4723
        #skip the last revision in the list
 
4724
        iterator.next()
 
4725
        while True:
 
4726
            if (stop_index is not None and
 
4727
                len(partial_history_cache) > stop_index):
 
4728
                break
 
4729
            if partial_history_cache[-1] == stop_revision:
 
4730
                break
 
4731
            revision_id = iterator.next()
 
4732
            partial_history_cache.append(revision_id)
 
4733
    except StopIteration:
 
4734
        # No more history
 
4735
        return
 
4736