← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-12-13 14:10:47 UTC
  • mfrom: (3106.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20071213141047-tklbta8rymzfpj6y
cherrypicking/rebasing section for User Guide

Show diffs side-by-side

added added

removed removed

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