~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Aaron Bentley
  • Date: 2007-06-11 14:59:52 UTC
  • mto: (2520.5.2 bzr.mpbundle)
  • mto: This revision was merged to the branch mainline in revision 2631.
  • Revision ID: abentley@panoramicfeedback.com-20070611145952-cwt4480gphdhen6l
Get installation started

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
import unittest
23
24
 
24
25
from bzrlib import (
25
 
    config,
26
 
    controldir,
27
 
    debug,
 
26
    bzrdir,
 
27
    check,
 
28
    errors,
28
29
    generate_ids,
 
30
    gpg,
29
31
    graph,
 
32
    lazy_regex,
30
33
    lockable_files,
31
34
    lockdir,
32
35
    osutils,
 
36
    registry,
 
37
    remote,
33
38
    revision as _mod_revision,
34
 
    testament as _mod_testament,
35
 
    tsort,
36
 
    gpg,
37
 
    )
38
 
from bzrlib.bundle import serializer
39
 
from bzrlib.i18n import gettext
40
 
""")
41
 
 
42
 
from bzrlib import (
43
 
    bzrdir,
44
 
    errors,
45
 
    registry,
46
39
    symbol_versioning,
 
40
    transactions,
47
41
    ui,
48
42
    )
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
43
from bzrlib.revisiontree import RevisionTree
 
44
from bzrlib.store.versioned import VersionedFileStore
 
45
from bzrlib.store.text import TextStore
 
46
from bzrlib.testament import Testament
 
47
 
 
48
""")
 
49
 
 
50
from bzrlib.decorators import needs_read_lock, needs_write_lock
50
51
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)
 
52
from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID
 
53
from bzrlib.symbol_versioning import (
 
54
        deprecated_method,
 
55
        zero_nine,
 
56
        )
 
57
from bzrlib.trace import mutter, note, warning
54
58
 
55
59
 
56
60
# Old formats display a warning, but only once
57
61
_deprecation_warning_done = False
58
62
 
59
63
 
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
 
class CommitBuilder(object):
69
 
    """Provides an interface to build up a commit.
70
 
 
71
 
    This allows describing a tree to be committed without needing to
72
 
    know the internals of the format of the repository.
73
 
    """
74
 
 
75
 
    # all clients should supply tree roots.
76
 
    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
82
 
 
83
 
    def __init__(self, repository, parents, config_stack, timestamp=None,
84
 
                 timezone=None, committer=None, revprops=None,
85
 
                 revision_id=None, lossy=False):
86
 
        """Initiate a CommitBuilder.
87
 
 
88
 
        :param repository: Repository to commit to.
89
 
        :param parents: Revision ids of the parents of the new revision.
90
 
        :param timestamp: Optional timestamp recorded for commit.
91
 
        :param timezone: Optional timezone for timestamp.
92
 
        :param committer: Optional committer to set for commit.
93
 
        :param revprops: Optional dictionary of revision properties.
94
 
        :param revision_id: Optional revision id.
95
 
        :param lossy: Whether to discard data that can not be natively
96
 
            represented, when pushing to a foreign VCS 
97
 
        """
98
 
        self._config_stack = config_stack
99
 
        self._lossy = lossy
100
 
 
101
 
        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
105
 
        else:
106
 
            self._committer = committer
107
 
 
108
 
        self._new_revision_id = revision_id
109
 
        self.parents = parents
110
 
        self.repository = repository
111
 
 
112
 
        self._revprops = {}
113
 
        if revprops is not None:
114
 
            self._validate_revprops(revprops)
115
 
            self._revprops.update(revprops)
116
 
 
117
 
        if timestamp is None:
118
 
            timestamp = time.time()
119
 
        # Restrict resolution to 1ms
120
 
        self._timestamp = round(timestamp, 3)
121
 
 
122
 
        if timezone is None:
123
 
            self._timezone = osutils.local_time_offset()
124
 
        else:
125
 
            self._timezone = int(timezone)
126
 
 
127
 
        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,))
153
 
 
154
 
    def commit(self, message):
155
 
        """Make the actual commit.
156
 
 
157
 
        :return: The revision id of the recorded revision.
158
 
        """
159
 
        raise NotImplementedError(self.commit)
160
 
 
161
 
    def abort(self):
162
 
        """Abort the commit that is being built.
163
 
        """
164
 
        raise NotImplementedError(self.abort)
165
 
 
166
 
    def revision_tree(self):
167
 
        """Return the tree that was just committed.
168
 
 
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
173
 
        memory.
174
 
        """
175
 
        raise NotImplementedError(self.revision_tree)
176
 
 
177
 
    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)
184
 
 
185
 
    def _gen_revision_id(self):
186
 
        """Return new revision-id."""
187
 
        return generate_ids.gen_revision_id(self._committer, self._timestamp)
188
 
 
189
 
    def _generate_revision_if_needed(self):
190
 
        """Create a revision id if None was supplied.
191
 
 
192
 
        If the repository can not support user-specified revision ids
193
 
        they should override this function and raise CannotSetRevisionId
194
 
        if _new_revision_id is not None.
195
 
 
196
 
        :raises: CannotSetRevisionId
197
 
        """
198
 
        if self._new_revision_id is None:
199
 
            self._new_revision_id = self._gen_revision_id()
200
 
            self.random_revid = True
201
 
        else:
202
 
            self.random_revid = False
203
 
 
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)
245
 
 
246
 
 
247
64
######################################################################
248
65
# Repositories
249
66
 
250
 
 
251
 
class Repository(_RelockDebugMixin, controldir.ControlComponent):
 
67
class Repository(object):
252
68
    """Repository holding history for one or more branches.
253
69
 
254
70
    The repository holds and retrieves historical information including
255
71
    revisions and file history.  It's normally accessed only by the Branch,
256
72
    which views a particular line of development through that history.
257
73
 
258
 
    See VersionedFileRepository in bzrlib.vf_repository for the
259
 
    base class for most Bazaar repositories.
 
74
    The Repository builds on top of Stores and a Transport, which respectively 
 
75
    describe the disk data format and the way of accessing the (possibly 
 
76
    remote) disk.
260
77
    """
261
78
 
262
 
    def abort_write_group(self, suppress_errors=False):
263
 
        """Commit the contents accrued within the current write group.
264
 
 
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
 
        :seealso: start_write_group.
270
 
        """
271
 
        if self._write_group is not self.get_transaction():
272
 
            # 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)
290
 
        self._write_group = None
291
 
 
292
 
    def _abort_write_group(self):
293
 
        """Template method for per-repository write group cleanup.
294
 
 
295
 
        This is called during abort before the write group is considered to be
296
 
        finished and should cleanup any internal state accrued during the write
297
 
        group. There is no requirement that data handed to the repository be
298
 
        *not* made available - this is not a rollback - but neither should any
299
 
        attempt be made to ensure that data added is fully commited. Abort is
300
 
        invoked when an error has occured so futher disk or network operations
301
 
        may not be possible or may error and if possible should not be
302
 
        attempted.
303
 
        """
304
 
 
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)
 
79
    _file_ids_altered_regex = lazy_regex.lazy_compile(
 
80
        r'file_id="(?P<file_id>[^"]+)"'
 
81
        r'.*revision="(?P<revision_id>[^"]+)"'
 
82
        )
 
83
 
 
84
    @needs_write_lock
 
85
    def add_inventory(self, revision_id, inv, parents):
 
86
        """Add the inventory inv to the repository as revision_id.
 
87
        
 
88
        :param parents: The revision ids of the parents that revision_id
 
89
                        is known to have and are in the repository already.
 
90
 
 
91
        returns the sha1 of the serialized inventory.
 
92
        """
 
93
        revision_id = osutils.safe_revision_id(revision_id)
 
94
        _mod_revision.check_not_reserved_id(revision_id)
 
95
        assert inv.revision_id is None or inv.revision_id == revision_id, \
 
96
            "Mismatch between inventory revision" \
 
97
            " id and insertion revid (%r, %r)" % (inv.revision_id, revision_id)
 
98
        assert inv.root is not None
 
99
        inv_text = self.serialise_inventory(inv)
 
100
        inv_sha1 = osutils.sha_string(inv_text)
 
101
        inv_vf = self.control_weaves.get_weave('inventory',
 
102
                                               self.get_transaction())
 
103
        self._inventory_add_lines(inv_vf, revision_id, parents,
 
104
                                  osutils.split_lines(inv_text))
 
105
        return inv_sha1
 
106
 
 
107
    def _inventory_add_lines(self, inv_vf, revision_id, parents, lines):
 
108
        final_parents = []
 
109
        for parent in parents:
 
110
            if parent in inv_vf:
 
111
                final_parents.append(parent)
 
112
 
 
113
        inv_vf.add_lines(revision_id, final_parents, lines)
 
114
 
 
115
    @needs_write_lock
 
116
    def add_revision(self, revision_id, rev, inv=None, config=None):
 
117
        """Add rev to the revision store as revision_id.
 
118
 
 
119
        :param revision_id: the revision id to use.
 
120
        :param rev: The revision object.
 
121
        :param inv: The inventory for the revision. if None, it will be looked
 
122
                    up in the inventory storer
 
123
        :param config: If None no digital signature will be created.
 
124
                       If supplied its signature_needed method will be used
 
125
                       to determine if a signature should be made.
 
126
        """
 
127
        revision_id = osutils.safe_revision_id(revision_id)
 
128
        # TODO: jam 20070210 Shouldn't we check rev.revision_id and
 
129
        #       rev.parent_ids?
 
130
        _mod_revision.check_not_reserved_id(revision_id)
 
131
        if config is not None and config.signature_needed():
 
132
            if inv is None:
 
133
                inv = self.get_inventory(revision_id)
 
134
            plaintext = Testament(rev, inv).as_short_text()
 
135
            self.store_revision_signature(
 
136
                gpg.GPGStrategy(config), plaintext, revision_id)
 
137
        if not revision_id in self.get_inventory_weave():
 
138
            if inv is None:
 
139
                raise errors.WeaveRevisionNotPresent(revision_id,
 
140
                                                     self.get_inventory_weave())
 
141
            else:
 
142
                # yes, this is not suitable for adding with ghosts.
 
143
                self.add_inventory(revision_id, inv, rev.parent_ids)
 
144
        self._revision_store.add_revision(rev, self.get_transaction())
 
145
 
 
146
    @needs_read_lock
 
147
    def _all_possible_ids(self):
 
148
        """Return all the possible revisions that we could find."""
 
149
        return self.get_inventory_weave().versions()
320
150
 
321
151
    def all_revision_ids(self):
322
 
        """Returns a list of all the revision ids in the repository.
 
152
        """Returns a list of all the revision ids in the repository. 
323
153
 
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.
 
154
        This is deprecated because code should generally work on the graph
 
155
        reachable from a particular revision, and ignore any other revisions
 
156
        that might be present.  There is no direct replacement method.
328
157
        """
329
 
        if 'evil' in debug.debug_flags:
330
 
            mutter_callsite(2, "all_revision_ids is linear with history.")
331
158
        return self._all_revision_ids()
332
159
 
 
160
    @needs_read_lock
333
161
    def _all_revision_ids(self):
334
 
        """Returns a list of all the revision ids in the repository.
 
162
        """Returns a list of all the revision ids in the repository. 
335
163
 
336
 
        These are in as much topological order as the underlying store can
337
 
        present.
 
164
        These are in as much topological order as the underlying store can 
 
165
        present: for weaves ghosts may lead to a lack of correctness until
 
166
        the reweave updates the parents list.
338
167
        """
339
 
        raise NotImplementedError(self._all_revision_ids)
 
168
        if self._revision_store.text_store.listable():
 
169
            return self._revision_store.all_revision_ids(self.get_transaction())
 
170
        result = self._all_possible_ids()
 
171
        # TODO: jam 20070210 Ensure that _all_possible_ids returns non-unicode
 
172
        #       ids. (It should, since _revision_store's API should change to
 
173
        #       return utf8 revision_ids)
 
174
        return self._eliminate_revisions_not_present(result)
340
175
 
341
176
    def break_lock(self):
342
177
        """Break a lock if one is present from another instance.
346
181
        """
347
182
        self.control_files.break_lock()
348
183
 
 
184
    @needs_read_lock
 
185
    def _eliminate_revisions_not_present(self, revision_ids):
 
186
        """Check every revision id in revision_ids to see if we have it.
 
187
 
 
188
        Returns a set of the present revisions.
 
189
        """
 
190
        result = []
 
191
        for id in revision_ids:
 
192
            if self.has_revision(id):
 
193
               result.append(id)
 
194
        return result
 
195
 
349
196
    @staticmethod
350
 
    def create(controldir):
351
 
        """Construct the current default format repository in controldir."""
352
 
        return RepositoryFormat.get_default_format().initialize(controldir)
 
197
    def create(a_bzrdir):
 
198
        """Construct the current default format repository in a_bzrdir."""
 
199
        return RepositoryFormat.get_default_format().initialize(a_bzrdir)
353
200
 
354
 
    def __init__(self, _format, controldir, control_files):
 
201
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
355
202
        """instantiate a Repository.
356
203
 
357
204
        :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.
 
205
        :param a_bzrdir: The BzrDir of the repository.
 
206
 
 
207
        In the future we will have a single api for all stores for
 
208
        getting file texts, inventories and revisions, then
 
209
        this construct will accept instances of those things.
360
210
        """
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
211
        super(Repository, self).__init__()
365
212
        self._format = _format
366
213
        # the following are part of the public API for Repository:
367
 
        self.bzrdir = controldir
 
214
        self.bzrdir = a_bzrdir
368
215
        self.control_files = control_files
369
 
        # for tests
370
 
        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
 
216
        self._revision_store = _revision_store
 
217
        self.text_store = text_store
 
218
        # backwards compatibility
 
219
        self.weave_store = text_store
 
220
        # not right yet - should be more semantically clear ? 
 
221
        # 
 
222
        self.control_store = control_store
 
223
        self.control_weaves = control_store
 
224
        # TODO: make sure to construct the right store classes, etc, depending
 
225
        # on whether escaping is required.
 
226
        self._warn_if_deprecated()
381
227
 
382
228
    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
402
 
 
403
 
    def has_same_location(self, other):
404
 
        """Returns a boolean indicating if this repository is at the same
405
 
        location as another repository.
406
 
 
407
 
        This might return False even when two repository objects are accessing
408
 
        the same physical repository via different URLs.
409
 
        """
410
 
        if self.__class__ is not other.__class__:
411
 
            return False
412
 
        return (self.control_url == other.control_url)
413
 
 
414
 
    def is_in_write_group(self):
415
 
        """Return True if there is an open write group.
416
 
 
417
 
        :seealso: start_write_group.
418
 
        """
419
 
        return self._write_group is not None
 
229
        return '%s(%r)' % (self.__class__.__name__, 
 
230
                           self.bzrdir.transport.base)
420
231
 
421
232
    def is_locked(self):
422
233
        return self.control_files.is_locked()
423
234
 
424
 
    def is_write_locked(self):
425
 
        """Return True if this object is write locked."""
426
 
        return self.is_locked() and self.control_files._lock_mode == 'w'
427
 
 
428
235
    def lock_write(self, token=None):
429
236
        """Lock this repository for writing.
430
 
 
431
 
        This causes caching within the repository obejct to start accumlating
432
 
        data during reads, and allows a 'write_group' to be obtained. Write
433
 
        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
 
 
 
237
        
441
238
        :param token: if this is already locked, then lock_write will fail
442
239
            unless the token matches the existing lock.
443
240
        :returns: a token if this instance supports tokens, otherwise None.
445
242
            instance doesn't support using token locks.
446
243
        :raises MismatchedToken: if the specified token doesn't match the token
447
244
            of the existing lock.
448
 
        :seealso: start_write_group.
449
 
        :return: A RepositoryWriteLockResult.
 
245
 
 
246
        A token should be passed in if you know that you have locked the object
 
247
        some other way, and need to synchronise this object's state with that
 
248
        fact.
 
249
 
 
250
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
450
251
        """
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)
 
252
        return self.control_files.lock_write(token=token)
461
253
 
462
254
    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
255
        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)
477
256
 
478
257
    def get_physical_lock_status(self):
479
258
        return self.control_files.get_physical_lock_status()
481
260
    def leave_lock_in_place(self):
482
261
        """Tell this repository not to release the physical lock when this
483
262
        object is unlocked.
484
 
 
 
263
        
485
264
        If lock_write doesn't return a token, then this method is not supported.
486
265
        """
487
266
        self.control_files.leave_in_place()
515
294
        if revid and committers:
516
295
            result['committers'] = 0
517
296
        if revid and revid != _mod_revision.NULL_REVISION:
518
 
            graph = self.get_graph()
519
297
            if committers:
520
298
                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
 
299
            revisions = self.get_ancestry(revid)
 
300
            # pop the leading None
 
301
            revisions.pop(0)
 
302
            first_revision = None
524
303
            if not committers:
525
304
                # ignore the revisions in the middle - just grab first and last
526
305
                revisions = revisions[0], revisions[-1]
527
306
            for revision in self.get_revisions(revisions):
528
 
                if not last_revision:
529
 
                    last_revision = revision
 
307
                if not first_revision:
 
308
                    first_revision = revision
530
309
                if committers:
531
310
                    all_committers.add(revision.committer)
532
 
            first_revision = revision
 
311
            last_revision = revision
533
312
            if committers:
534
313
                result['committers'] = len(all_committers)
535
314
            result['firstrev'] = (first_revision.timestamp,
536
315
                first_revision.timezone)
537
316
            result['latestrev'] = (last_revision.timestamp,
538
317
                last_revision.timezone)
 
318
 
 
319
        # now gather global repository information
 
320
        if self.bzrdir.root_transport.listable():
 
321
            c, t = self._revision_store.total_size(self.get_transaction())
 
322
            result['revisions'] = c
 
323
            result['size'] = t
539
324
        return result
540
325
 
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.
547
 
        """
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
577
 
 
578
326
    @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):
 
327
    def missing_revision_ids(self, other, revision_id=None):
583
328
        """Return the revision ids that other has that this does not.
584
 
 
 
329
        
585
330
        These are returned in topological order.
586
331
 
587
332
        revision_id: only return revision ids included by revision_id.
588
333
        """
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)
 
334
        revision_id = osutils.safe_revision_id(revision_id)
 
335
        return InterRepository.get(other, self).missing_revision_ids(revision_id)
602
336
 
603
337
    @staticmethod
604
338
    def open(base):
607
341
        For instance, if the repository is at URL/.bzr/repository,
608
342
        Repository.open(URL) -> a Repository instance.
609
343
        """
610
 
        control = controldir.ControlDir.open(base)
 
344
        control = bzrdir.BzrDir.open(base)
611
345
        return control.open_repository()
612
346
 
613
347
    def copy_content_into(self, destination, revision_id=None):
614
348
        """Make a complete copy of the content in self into destination.
615
 
 
616
 
        This is a destructive operation! Do not use it on existing
 
349
        
 
350
        This is a destructive operation! Do not use it on existing 
617
351
        repositories.
618
352
        """
 
353
        revision_id = osutils.safe_revision_id(revision_id)
619
354
        return InterRepository.get(self, destination).copy_content(revision_id)
620
355
 
621
 
    def commit_write_group(self):
622
 
        """Commit the contents accrued within the current write group.
623
 
 
624
 
        :seealso: start_write_group.
625
 
        
626
 
        :return: it may return an opaque hint that can be passed to 'pack'.
627
 
        """
628
 
        if self._write_group is not self.get_transaction():
629
 
            # has an unlock or relock occured ?
630
 
            raise errors.BzrError('mismatched lock context %r and '
631
 
                'write group %r.' %
632
 
                (self.get_transaction(), self._write_group))
633
 
        result = self._commit_write_group()
634
 
        self._write_group = None
635
 
        return result
636
 
 
637
 
    def _commit_write_group(self):
638
 
        """Template method for per-repository write group cleanup.
639
 
 
640
 
        This is called before the write group is considered to be
641
 
        finished and should ensure that all data handed to the repository
642
 
        for writing during the write group is safely committed (to the
643
 
        extent possible considering file system caching etc).
644
 
        """
645
 
 
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):
 
356
    def fetch(self, source, revision_id=None, pb=None):
681
357
        """Fetch the content required to construct revision_id from source.
682
358
 
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
 
 
689
 
        :param find_ghosts: Find and copy revisions in the source that are
690
 
            ghosts in the target (and not reachable directly by walking out to
691
 
            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.
 
359
        If revision_id is None all content is copied.
695
360
        """
696
 
        if self.is_in_write_group():
697
 
            raise errors.InternalBzrError(
698
 
                "May not fetch while in a write group.")
699
 
        # 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)):
704
 
            # check that last_revision is in 'from' and then return a
705
 
            # no-operation.
706
 
            if (revision_id is not None and
707
 
                not _mod_revision.is_null(revision_id)):
708
 
                self.get_revision(revision_id)
709
 
            return 0, []
 
361
        revision_id = osutils.safe_revision_id(revision_id)
710
362
        inter = InterRepository.get(source, self)
711
 
        return inter.fetch(revision_id=revision_id, find_ghosts=find_ghosts)
712
 
 
713
 
    def create_bundle(self, target, base, fileobj, format=None):
714
 
        return serializer.write_bundle(self, target, base, fileobj, format)
715
 
 
716
 
    def get_commit_builder(self, branch, parents, config_stack, timestamp=None,
717
 
                           timezone=None, committer=None, revprops=None,
718
 
                           revision_id=None, lossy=False):
 
363
        try:
 
364
            return inter.fetch(revision_id=revision_id, pb=pb)
 
365
        except NotImplementedError:
 
366
            raise errors.IncompatibleRepositories(source, self)
 
367
 
 
368
    def get_commit_builder(self, branch, parents, config, timestamp=None, 
 
369
                           timezone=None, committer=None, revprops=None, 
 
370
                           revision_id=None):
719
371
        """Obtain a CommitBuilder for this repository.
720
 
 
 
372
        
721
373
        :param branch: Branch to commit to.
722
374
        :param parents: Revision ids of the parents of the new revision.
723
 
        :param config_stack: Configuration stack to use.
 
375
        :param config: Configuration to use.
724
376
        :param timestamp: Optional timestamp recorded for commit.
725
377
        :param timezone: Optional timezone for timestamp.
726
378
        :param committer: Optional committer to set for commit.
727
379
        :param revprops: Optional dictionary of revision properties.
728
380
        :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
381
        """
732
 
        raise NotImplementedError(self.get_commit_builder)
 
382
        revision_id = osutils.safe_revision_id(revision_id)
 
383
        return _CommitBuilder(self, parents, config, timestamp, timezone,
 
384
                              committer, revprops, revision_id)
733
385
 
734
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
735
386
    def unlock(self):
736
 
        if (self.control_files._lock_count == 1 and
737
 
            self.control_files._lock_mode == 'w'):
738
 
            if self._write_group is not None:
739
 
                self.abort_write_group()
740
 
                self.control_files.unlock()
741
 
                raise errors.BzrError(
742
 
                    'Must end write groups before releasing write locks.')
743
387
        self.control_files.unlock()
744
 
        if self.control_files._lock_count == 0:
745
 
            for repo in self._fallback_repositories:
746
 
                repo.unlock()
747
388
 
748
389
    @needs_read_lock
749
 
    def clone(self, controldir, revision_id=None):
750
 
        """Clone this repository into controldir using the current format.
 
390
    def clone(self, a_bzrdir, revision_id=None):
 
391
        """Clone this repository into a_bzrdir using the current format.
751
392
 
752
393
        Currently no check is made that the format of this repository and
753
394
        the bzrdir format are compatible. FIXME RBC 20060201.
756
397
        """
757
398
        # TODO: deprecate after 0.16; cloning this with all its settings is
758
399
        # probably not very useful -- mbp 20070423
759
 
        dest_repo = self._create_sprouting_repo(
760
 
            controldir, shared=self.is_shared())
 
400
        dest_repo = self._create_sprouting_repo(a_bzrdir, shared=self.is_shared())
761
401
        self.copy_content_into(dest_repo, revision_id)
762
402
        return dest_repo
763
403
 
764
 
    def start_write_group(self):
765
 
        """Start a write group in the repository.
766
 
 
767
 
        Write groups are used by repositories which do not have a 1:1 mapping
768
 
        between file ids and backend store to manage the insertion of data from
769
 
        both fetch and commit operations.
770
 
 
771
 
        A write lock is required around the start_write_group/commit_write_group
772
 
        for the support of lock-requiring repository formats.
773
 
 
774
 
        One can only insert data into a repository inside a write group.
775
 
 
776
 
        :return: None.
777
 
        """
778
 
        if not self.is_write_locked():
779
 
            raise errors.NotWriteLocked(self)
780
 
        if self._write_group:
781
 
            raise errors.BzrError('already in a write group')
782
 
        self._start_write_group()
783
 
        # so we can detect unlock/relock - the write group is now entered.
784
 
        self._write_group = self.get_transaction()
785
 
 
786
 
    def _start_write_group(self):
787
 
        """Template method for per-repository write group startup.
788
 
 
789
 
        This is called before the write group is considered to be
790
 
        entered.
791
 
        """
792
 
 
793
404
    @needs_read_lock
794
405
    def sprout(self, to_bzrdir, revision_id=None):
795
406
        """Create a descendent repository for new development.
816
427
    @needs_read_lock
817
428
    def has_revision(self, revision_id):
818
429
        """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)
829
 
 
830
 
    @needs_read_lock
831
 
    def get_revision(self, revision_id):
832
 
        """Return the Revision object for a named revision."""
833
 
        return self.get_revisions([revision_id])[0]
834
 
 
 
430
        revision_id = osutils.safe_revision_id(revision_id)
 
431
        return self._revision_store.has_revision_id(revision_id,
 
432
                                                    self.get_transaction())
 
433
 
 
434
    @needs_read_lock
835
435
    def get_revision_reconcile(self, revision_id):
836
436
        """'reconcile' helper routine that allows access to a revision always.
837
 
 
 
437
        
838
438
        This variant of get_revision does not cross check the weave graph
839
439
        against the revision one as get_revision does: but it should only
840
440
        be used by reconcile, or reconcile-alike commands that are correcting
841
441
        or testing the revision graph.
842
442
        """
843
 
        raise NotImplementedError(self.get_revision_reconcile)
 
443
        if not revision_id or not isinstance(revision_id, basestring):
 
444
            raise errors.InvalidRevisionId(revision_id=revision_id,
 
445
                                           branch=self)
 
446
        return self.get_revisions([revision_id])[0]
844
447
 
 
448
    @needs_read_lock
845
449
    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):
 
450
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
451
        revs = self._revision_store.get_revisions(revision_ids,
 
452
                                                  self.get_transaction())
 
453
        for rev in revs:
 
454
            assert not isinstance(rev.revision_id, unicode)
 
455
            for parent_id in rev.parent_ids:
 
456
                assert not isinstance(parent_id, unicode)
 
457
        return revs
 
458
 
 
459
    @needs_read_lock
 
460
    def get_revision_xml(self, revision_id):
 
461
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
 
462
        #       would have already do it.
 
463
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
 
464
        revision_id = osutils.safe_revision_id(revision_id)
 
465
        rev = self.get_revision(revision_id)
 
466
        rev_tmp = StringIO()
 
467
        # the current serializer..
 
468
        self._revision_store._serializer.write_revision(rev, rev_tmp)
 
469
        rev_tmp.seek(0)
 
470
        return rev_tmp.getvalue()
 
471
 
 
472
    @needs_read_lock
 
473
    def get_revision(self, revision_id):
 
474
        """Return the Revision object for a named revision"""
 
475
        # TODO: jam 20070210 get_revision_reconcile should do this for us
 
476
        revision_id = osutils.safe_revision_id(revision_id)
 
477
        r = self.get_revision_reconcile(revision_id)
 
478
        # weave corruption can lead to absent revision markers that should be
 
479
        # present.
 
480
        # the following test is reasonably cheap (it needs a single weave read)
 
481
        # and the weave is cached in read transactions. In write transactions
 
482
        # it is not cached but typically we only read a small number of
 
483
        # revisions. For knits when they are introduced we will probably want
 
484
        # to ensure that caching write transactions are in use.
 
485
        inv = self.get_inventory_weave()
 
486
        self._check_revision_parents(r, inv)
 
487
        return r
 
488
 
 
489
    @needs_read_lock
 
490
    def get_deltas_for_revisions(self, revisions):
854
491
        """Produce a generator of revision deltas.
855
 
 
 
492
        
856
493
        Note that the input is a sequence of REVISIONS, not revision_ids.
857
494
        Trees will be held in memory until the generator exits.
858
495
        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
496
        """
864
 
        # Get the revision-ids of interest
865
497
        required_trees = set()
866
498
        for revision in revisions:
867
499
            required_trees.add(revision.revision_id)
868
500
            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
 
501
        trees = dict((t.get_revision_id(), t) for 
 
502
                     t in self.revision_trees(required_trees))
885
503
        for revision in revisions:
886
504
            if not revision.parent_ids:
887
 
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
 
505
                old_tree = self.revision_tree(None)
888
506
            else:
889
507
                old_tree = trees[revision.parent_ids[0]]
890
508
            yield trees[revision.revision_id].changes_from(old_tree)
891
509
 
892
510
    @needs_read_lock
893
 
    def get_revision_delta(self, revision_id, specific_fileids=None):
 
511
    def get_revision_delta(self, revision_id):
894
512
        """Return the delta for one revision.
895
513
 
896
514
        The delta is relative to the left-hand predecessor of the
897
515
        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
516
        """
903
517
        r = self.get_revision(revision_id)
904
 
        return list(self.get_deltas_for_revisions([r],
905
 
            specific_fileids=specific_fileids))[0]
 
518
        return list(self.get_deltas_for_revisions([r]))[0]
 
519
 
 
520
    def _check_revision_parents(self, revision, inventory):
 
521
        """Private to Repository and Fetch.
 
522
        
 
523
        This checks the parentage of revision in an inventory weave for 
 
524
        consistency and is only applicable to inventory-weave-for-ancestry
 
525
        using repository formats & fetchers.
 
526
        """
 
527
        weave_parents = inventory.get_parents(revision.revision_id)
 
528
        weave_names = inventory.versions()
 
529
        for parent_id in revision.parent_ids:
 
530
            if parent_id in weave_names:
 
531
                # this parent must not be a ghost.
 
532
                if not parent_id in weave_parents:
 
533
                    # but it is a ghost
 
534
                    raise errors.CorruptRepository(self)
906
535
 
907
536
    @needs_write_lock
908
537
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
538
        revision_id = osutils.safe_revision_id(revision_id)
909
539
        signature = gpg_strategy.sign(plaintext)
910
 
        self.add_signature_text(revision_id, signature)
911
 
 
912
 
    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
932
 
 
933
 
    def iter_files_bytes(self, desired_files):
934
 
        """Iterate through file versions.
935
 
 
936
 
        Files will not necessarily be returned in the order they occur in
937
 
        desired_files.  No specific order is guaranteed.
938
 
 
939
 
        Yields pairs of identifier, bytes_iterator.  identifier is an opaque
940
 
        value supplied by the caller as part of desired_files.  It should
941
 
        uniquely identify the file version in the caller's context.  (Examples:
942
 
        an index number or a TreeTransform trans_id.)
943
 
 
944
 
        :param desired_files: a list of (file_id, revision_id, identifier)
945
 
            triples
946
 
        """
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
 
 
984
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
 
540
        self._revision_store.add_revision_signature_text(revision_id,
 
541
                                                         signature,
 
542
                                                         self.get_transaction())
 
543
 
 
544
    def fileids_altered_by_revision_ids(self, revision_ids):
 
545
        """Find the file ids and versions affected by revisions.
 
546
 
 
547
        :param revisions: an iterable containing revision ids.
 
548
        :return: a dictionary mapping altered file-ids to an iterable of
 
549
        revision_ids. Each altered file-ids has the exact revision_ids that
 
550
        altered it listed explicitly.
 
551
        """
 
552
        assert self._serializer.support_altered_by_hack, \
 
553
            ("fileids_altered_by_revision_ids only supported for branches " 
 
554
             "which store inventory as unnested xml, not on %r" % self)
 
555
        selected_revision_ids = set(osutils.safe_revision_id(r)
 
556
                                    for r in revision_ids)
 
557
        w = self.get_inventory_weave()
 
558
        result = {}
 
559
 
 
560
        # this code needs to read every new line in every inventory for the
 
561
        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
 
562
        # not present in one of those inventories is unnecessary but not 
 
563
        # harmful because we are filtering by the revision id marker in the
 
564
        # inventory lines : we only select file ids altered in one of those  
 
565
        # revisions. We don't need to see all lines in the inventory because
 
566
        # only those added in an inventory in rev X can contain a revision=X
 
567
        # line.
 
568
        unescape_revid_cache = {}
 
569
        unescape_fileid_cache = {}
 
570
 
 
571
        # jam 20061218 In a big fetch, this handles hundreds of thousands
 
572
        # of lines, so it has had a lot of inlining and optimizing done.
 
573
        # Sorry that it is a little bit messy.
 
574
        # Move several functions to be local variables, since this is a long
 
575
        # running loop.
 
576
        search = self._file_ids_altered_regex.search
 
577
        unescape = _unescape_xml
 
578
        setdefault = result.setdefault
 
579
        pb = ui.ui_factory.nested_progress_bar()
 
580
        try:
 
581
            for line in w.iter_lines_added_or_present_in_versions(
 
582
                                        selected_revision_ids, pb=pb):
 
583
                match = search(line)
 
584
                if match is None:
 
585
                    continue
 
586
                # One call to match.group() returning multiple items is quite a
 
587
                # bit faster than 2 calls to match.group() each returning 1
 
588
                file_id, revision_id = match.group('file_id', 'revision_id')
 
589
 
 
590
                # Inlining the cache lookups helps a lot when you make 170,000
 
591
                # lines and 350k ids, versus 8.4 unique ids.
 
592
                # Using a cache helps in 2 ways:
 
593
                #   1) Avoids unnecessary decoding calls
 
594
                #   2) Re-uses cached strings, which helps in future set and
 
595
                #      equality checks.
 
596
                # (2) is enough that removing encoding entirely along with
 
597
                # the cache (so we are using plain strings) results in no
 
598
                # performance improvement.
 
599
                try:
 
600
                    revision_id = unescape_revid_cache[revision_id]
 
601
                except KeyError:
 
602
                    unescaped = unescape(revision_id)
 
603
                    unescape_revid_cache[revision_id] = unescaped
 
604
                    revision_id = unescaped
 
605
 
 
606
                if revision_id in selected_revision_ids:
 
607
                    try:
 
608
                        file_id = unescape_fileid_cache[file_id]
 
609
                    except KeyError:
 
610
                        unescaped = unescape(file_id)
 
611
                        unescape_fileid_cache[file_id] = unescaped
 
612
                        file_id = unescaped
 
613
                    setdefault(file_id, set()).add(revision_id)
 
614
        finally:
 
615
            pb.finished()
 
616
        return result
 
617
 
 
618
    @needs_read_lock
 
619
    def get_inventory_weave(self):
 
620
        return self.control_weaves.get_weave('inventory',
 
621
            self.get_transaction())
 
622
 
 
623
    @needs_read_lock
 
624
    def get_inventory(self, revision_id):
 
625
        """Get Inventory object by hash."""
 
626
        # TODO: jam 20070210 Technically we don't need to sanitize, since all
 
627
        #       called functions must sanitize.
 
628
        revision_id = osutils.safe_revision_id(revision_id)
 
629
        return self.deserialise_inventory(
 
630
            revision_id, self.get_inventory_xml(revision_id))
 
631
 
 
632
    def deserialise_inventory(self, revision_id, xml):
 
633
        """Transform the xml into an inventory object. 
 
634
 
 
635
        :param revision_id: The expected revision id of the inventory.
 
636
        :param xml: A serialised inventory.
 
637
        """
 
638
        revision_id = osutils.safe_revision_id(revision_id)
 
639
        result = self._serializer.read_inventory_from_string(xml)
 
640
        result.root.revision = revision_id
 
641
        return result
 
642
 
 
643
    def serialise_inventory(self, inv):
 
644
        return self._serializer.write_inventory_to_string(inv)
 
645
 
 
646
    @needs_read_lock
 
647
    def get_inventory_xml(self, revision_id):
 
648
        """Get inventory XML as a file object."""
 
649
        revision_id = osutils.safe_revision_id(revision_id)
 
650
        try:
 
651
            assert isinstance(revision_id, str), type(revision_id)
 
652
            iw = self.get_inventory_weave()
 
653
            return iw.get_text(revision_id)
 
654
        except IndexError:
 
655
            raise errors.HistoryMissing(self, 'inventory', revision_id)
 
656
 
 
657
    @needs_read_lock
 
658
    def get_inventory_sha1(self, revision_id):
 
659
        """Return the sha1 hash of the inventory entry
 
660
        """
 
661
        # TODO: jam 20070210 Shouldn't this be deprecated / removed?
 
662
        revision_id = osutils.safe_revision_id(revision_id)
 
663
        return self.get_revision(revision_id).inventory_sha1
 
664
 
 
665
    @needs_read_lock
 
666
    def get_revision_graph(self, revision_id=None):
 
667
        """Return a dictionary containing the revision graph.
 
668
        
 
669
        :param revision_id: The revision_id to get a graph from. If None, then
 
670
        the entire revision graph is returned. This is a deprecated mode of
 
671
        operation and will be removed in the future.
 
672
        :return: a dictionary of revision_id->revision_parents_list.
 
673
        """
 
674
        # special case NULL_REVISION
 
675
        if revision_id == _mod_revision.NULL_REVISION:
 
676
            return {}
 
677
        revision_id = osutils.safe_revision_id(revision_id)
 
678
        a_weave = self.get_inventory_weave()
 
679
        all_revisions = self._eliminate_revisions_not_present(
 
680
                                a_weave.versions())
 
681
        entire_graph = dict([(node, a_weave.get_parents(node)) for 
 
682
                             node in all_revisions])
 
683
        if revision_id is None:
 
684
            return entire_graph
 
685
        elif revision_id not in entire_graph:
 
686
            raise errors.NoSuchRevision(self, revision_id)
 
687
        else:
 
688
            # add what can be reached from revision_id
 
689
            result = {}
 
690
            pending = set([revision_id])
 
691
            while len(pending) > 0:
 
692
                node = pending.pop()
 
693
                result[node] = entire_graph[node]
 
694
                for revision_id in result[node]:
 
695
                    if revision_id not in result:
 
696
                        pending.add(revision_id)
 
697
            return result
 
698
 
 
699
    @needs_read_lock
 
700
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
701
        """Return a graph of the revisions with ghosts marked as applicable.
 
702
 
 
703
        :param revision_ids: an iterable of revisions to graph or None for all.
 
704
        :return: a Graph object with the graph reachable from revision_ids.
 
705
        """
 
706
        result = graph.Graph()
 
707
        if not revision_ids:
 
708
            pending = set(self.all_revision_ids())
 
709
            required = set([])
 
710
        else:
 
711
            pending = set(osutils.safe_revision_id(r) for r in revision_ids)
 
712
            # special case NULL_REVISION
 
713
            if _mod_revision.NULL_REVISION in pending:
 
714
                pending.remove(_mod_revision.NULL_REVISION)
 
715
            required = set(pending)
 
716
        done = set([])
 
717
        while len(pending):
 
718
            revision_id = pending.pop()
 
719
            try:
 
720
                rev = self.get_revision(revision_id)
 
721
            except errors.NoSuchRevision:
 
722
                if revision_id in required:
 
723
                    raise
 
724
                # a ghost
 
725
                result.add_ghost(revision_id)
 
726
                continue
 
727
            for parent_id in rev.parent_ids:
 
728
                # is this queued or done ?
 
729
                if (parent_id not in pending and
 
730
                    parent_id not in done):
 
731
                    # no, queue it.
 
732
                    pending.add(parent_id)
 
733
            result.add_node(revision_id, rev.parent_ids)
 
734
            done.add(revision_id)
 
735
        return result
 
736
 
 
737
    def _get_history_vf(self):
 
738
        """Get a versionedfile whose history graph reflects all revisions.
 
739
 
 
740
        For weave repositories, this is the inventory weave.
 
741
        """
 
742
        return self.get_inventory_weave()
 
743
 
985
744
    def iter_reverse_revision_history(self, revision_id):
986
745
        """Iterate backwards through revision ids in the lefthand history
987
746
 
988
747
        :param revision_id: The revision id to start with.  All its lefthand
989
748
            ancestors will be traversed.
990
749
        """
991
 
        graph = self.get_graph()
992
 
        stop_revisions = (None, _mod_revision.NULL_REVISION)
993
 
        return graph.iter_lefthand_ancestry(revision_id, stop_revisions)
994
 
 
 
750
        revision_id = osutils.safe_revision_id(revision_id)
 
751
        if revision_id in (None, _mod_revision.NULL_REVISION):
 
752
            return
 
753
        next_id = revision_id
 
754
        versionedfile = self._get_history_vf()
 
755
        while True:
 
756
            yield next_id
 
757
            parents = versionedfile.get_parents(next_id)
 
758
            if len(parents) == 0:
 
759
                return
 
760
            else:
 
761
                next_id = parents[0]
 
762
 
 
763
    @needs_read_lock
 
764
    def get_revision_inventory(self, revision_id):
 
765
        """Return inventory of a past revision."""
 
766
        # TODO: Unify this with get_inventory()
 
767
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
768
        # must be the same as its revision, so this is trivial.
 
769
        if revision_id is None:
 
770
            # This does not make sense: if there is no revision,
 
771
            # then it is the current tree inventory surely ?!
 
772
            # and thus get_root_id() is something that looks at the last
 
773
            # commit on the branch, and the get_root_id is an inventory check.
 
774
            raise NotImplementedError
 
775
            # return Inventory(self.get_root_id())
 
776
        else:
 
777
            return self.get_inventory(revision_id)
 
778
 
 
779
    @needs_read_lock
995
780
    def is_shared(self):
996
781
        """Return True if this repository is flagged as a shared repository."""
997
782
        raise NotImplementedError(self.is_shared)
1004
789
        reconciler.reconcile()
1005
790
        return reconciler
1006
791
 
1007
 
    def _refresh_data(self):
1008
 
        """Helper called from lock_* to ensure coherency with disk.
1009
 
 
1010
 
        The default implementation does nothing; it is however possible
1011
 
        for repositories to maintain loaded indices across multiple locks
1012
 
        by checking inside their implementation of this method to see
1013
 
        whether their indices are still valid. This depends of course on
1014
 
        the disk format being validatable in this manner. This method is
1015
 
        also called by the refresh_data() public interface to cause a refresh
1016
 
        to occur while in a write lock so that data inserted by a smart server
1017
 
        push operation is visible on the client's instance of the physical
1018
 
        repository.
1019
 
        """
1020
 
 
1021
792
    @needs_read_lock
1022
793
    def revision_tree(self, revision_id):
1023
794
        """Return Tree for a revision on this branch.
1024
795
 
1025
 
        `revision_id` may be NULL_REVISION for the empty tree revision.
 
796
        `revision_id` may be None for the empty tree revision.
1026
797
        """
1027
 
        raise NotImplementedError(self.revision_tree)
 
798
        # TODO: refactor this to use an existing revision object
 
799
        # so we don't need to read it in twice.
 
800
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
 
801
            return RevisionTree(self, Inventory(root_id=None), 
 
802
                                _mod_revision.NULL_REVISION)
 
803
        else:
 
804
            revision_id = osutils.safe_revision_id(revision_id)
 
805
            inv = self.get_revision_inventory(revision_id)
 
806
            return RevisionTree(self, inv, revision_id)
1028
807
 
 
808
    @needs_read_lock
1029
809
    def revision_trees(self, revision_ids):
1030
 
        """Return Trees for revisions in this repository.
 
810
        """Return Tree for a revision on this branch.
1031
811
 
1032
 
        :param revision_ids: a sequence of revision-ids;
1033
 
          a revision-id may not be None or 'null:'
1034
 
        """
1035
 
        raise NotImplementedError(self.revision_trees)
 
812
        `revision_id` may not be None or 'null:'"""
 
813
        assert None not in revision_ids
 
814
        assert _mod_revision.NULL_REVISION not in revision_ids
 
815
        texts = self.get_inventory_weave().get_texts(revision_ids)
 
816
        for text, revision_id in zip(texts, revision_ids):
 
817
            inv = self.deserialise_inventory(revision_id, text)
 
818
            yield RevisionTree(self, inv, revision_id)
1036
819
 
1037
820
    @needs_read_lock
1038
 
    @symbol_versioning.deprecated_method(
1039
 
        symbol_versioning.deprecated_in((2, 4, 0)))
1040
 
    def get_ancestry(self, revision_id, topo_sorted=True):
 
821
    def get_ancestry(self, revision_id):
1041
822
        """Return a list of revision-ids integrated by a revision.
1042
823
 
1043
 
        The first element of the list is always None, indicating the origin
1044
 
        revision.  This might change when we have history horizons, or
 
824
        The first element of the list is always None, indicating the origin 
 
825
        revision.  This might change when we have history horizons, or 
1045
826
        perhaps we should have a new API.
1046
 
 
 
827
        
1047
828
        This is topologically sorted.
1048
829
        """
1049
 
        if 'evil' in debug.debug_flags:
1050
 
            mutter_callsite(2, "get_ancestry is linear with history.")
1051
 
        if _mod_revision.is_null(revision_id):
 
830
        if revision_id is None:
1052
831
            return [None]
 
832
        revision_id = osutils.safe_revision_id(revision_id)
1053
833
        if not self.has_revision(revision_id):
1054
834
            raise errors.NoSuchRevision(self, revision_id)
1055
 
        graph = self.get_graph()
1056
 
        keys = set()
1057
 
        search = graph._make_breadth_first_searcher([revision_id])
1058
 
        while True:
1059
 
            try:
1060
 
                found, ghosts = search.next_with_ghosts()
1061
 
            except StopIteration:
1062
 
                break
1063
 
            keys.update(found)
1064
 
        if _mod_revision.NULL_REVISION in keys:
1065
 
            keys.remove(_mod_revision.NULL_REVISION)
1066
 
        if topo_sorted:
1067
 
            parent_map = graph.get_parent_map(keys)
1068
 
            keys = tsort.topo_sort(parent_map)
1069
 
        return [None] + list(keys)
1070
 
 
1071
 
    def pack(self, hint=None, clean_obsolete_packs=False):
1072
 
        """Compress the data within the repository.
1073
 
 
1074
 
        This operation only makes sense for some repository types. For other
1075
 
        types it should be a no-op that just returns.
1076
 
 
1077
 
        This stub method does not require a lock, but subclasses should use
1078
 
        @needs_write_lock as this is a long running call it's reasonable to
1079
 
        implicitly lock for the user.
1080
 
 
1081
 
        :param hint: If not supplied, the whole repository is packed.
1082
 
            If supplied, the repository may use the hint parameter as a
1083
 
            hint for the parts of the repository to pack. A hint can be
1084
 
            obtained from the result of commit_write_group(). Out of
1085
 
            date hints are simply ignored, because concurrent operations
1086
 
            can obsolete them rapidly.
1087
 
 
1088
 
        :param clean_obsolete_packs: Clean obsolete packs immediately after
1089
 
            the pack operation.
 
835
        w = self.get_inventory_weave()
 
836
        candidates = w.get_ancestry(revision_id)
 
837
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
 
838
 
 
839
    @needs_read_lock
 
840
    def print_file(self, file, revision_id):
 
841
        """Print `file` to stdout.
 
842
        
 
843
        FIXME RBC 20060125 as John Meinel points out this is a bad api
 
844
        - it writes to stdout, it assumes that that is valid etc. Fix
 
845
        by creating a new more flexible convenience function.
1090
846
        """
 
847
        revision_id = osutils.safe_revision_id(revision_id)
 
848
        tree = self.revision_tree(revision_id)
 
849
        # use inventory as it was in that revision
 
850
        file_id = tree.inventory.path2id(file)
 
851
        if not file_id:
 
852
            # TODO: jam 20060427 Write a test for this code path
 
853
            #       it had a bug in it, and was raising the wrong
 
854
            #       exception.
 
855
            raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
 
856
        tree.print_file(file_id)
1091
857
 
1092
858
    def get_transaction(self):
1093
859
        return self.control_files.get_transaction()
1094
860
 
1095
 
    def get_parent_map(self, revision_ids):
1096
 
        """See graph.StackedParentsProvider.get_parent_map"""
1097
 
        raise NotImplementedError(self.get_parent_map)
1098
 
 
1099
 
    def _get_parent_map_no_fallbacks(self, revision_ids):
1100
 
        """Same as Repository.get_parent_map except doesn't query fallbacks."""
1101
 
        # revisions index works in keys; this just works in revisions
1102
 
        # therefore wrap and unwrap
1103
 
        query_keys = []
1104
 
        result = {}
1105
 
        for revision_id in revision_ids:
1106
 
            if revision_id == _mod_revision.NULL_REVISION:
1107
 
                result[revision_id] = ()
1108
 
            elif revision_id is None:
1109
 
                raise ValueError('get_parent_map(None) is not valid')
1110
 
            else:
1111
 
                query_keys.append((revision_id ,))
1112
 
        vf = self.revisions.without_fallbacks()
1113
 
        for ((revision_id,), parent_keys) in \
1114
 
                vf.get_parent_map(query_keys).iteritems():
1115
 
            if parent_keys:
1116
 
                result[revision_id] = tuple([parent_revid
1117
 
                    for (parent_revid,) in parent_keys])
1118
 
            else:
1119
 
                result[revision_id] = (_mod_revision.NULL_REVISION,)
1120
 
        return result
1121
 
 
1122
 
    def _make_parents_provider(self):
1123
 
        if not self._format.supports_external_lookups:
1124
 
            return self
1125
 
        return graph.StackedParentsProvider(_LazyListJoin(
1126
 
            [self._make_parents_provider_unstacked()],
1127
 
            self._fallback_repositories))
1128
 
 
1129
 
    def _make_parents_provider_unstacked(self):
1130
 
        return graph.CallableToParentsProviderAdapter(
1131
 
            self._get_parent_map_no_fallbacks)
1132
 
 
1133
 
    @needs_read_lock
1134
 
    def get_known_graph_ancestry(self, revision_ids):
1135
 
        """Return the known graph for a set of revision ids and their ancestors.
1136
 
        """
1137
 
        raise NotImplementedError(self.get_known_graph_ancestry)
1138
 
 
1139
 
    def get_file_graph(self):
1140
 
        """Return the graph walker for files."""
1141
 
        raise NotImplementedError(self.get_file_graph)
1142
 
 
1143
 
    def get_graph(self, other_repository=None):
1144
 
        """Return the graph walker for this repository format"""
1145
 
        parents_provider = self._make_parents_provider()
1146
 
        if (other_repository is not None and
1147
 
            not self.has_same_location(other_repository)):
1148
 
            parents_provider = graph.StackedParentsProvider(
1149
 
                [parents_provider, other_repository._make_parents_provider()])
1150
 
        return graph.Graph(parents_provider)
 
861
    def revision_parents(self, revision_id):
 
862
        revision_id = osutils.safe_revision_id(revision_id)
 
863
        return self.get_inventory_weave().parent_names(revision_id)
1151
864
 
1152
865
    @needs_write_lock
1153
866
    def set_make_working_trees(self, new_value):
1160
873
                          working trees.
1161
874
        """
1162
875
        raise NotImplementedError(self.set_make_working_trees)
1163
 
 
 
876
    
1164
877
    def make_working_trees(self):
1165
878
        """Returns the policy for making working trees on new branches."""
1166
879
        raise NotImplementedError(self.make_working_trees)
1167
880
 
1168
881
    @needs_write_lock
1169
882
    def sign_revision(self, revision_id, gpg_strategy):
1170
 
        testament = _mod_testament.Testament.from_revision(self, revision_id)
1171
 
        plaintext = testament.as_short_text()
 
883
        revision_id = osutils.safe_revision_id(revision_id)
 
884
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
1172
885
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1173
886
 
1174
887
    @needs_read_lock
1175
 
    def verify_revision_signature(self, revision_id, gpg_strategy):
1176
 
        """Verify the signature on a revision.
1177
 
        
1178
 
        :param revision_id: the revision to verify
1179
 
        :gpg_strategy: the GPGStrategy object to used
1180
 
        
1181
 
        :return: gpg.SIGNATURE_VALID or a failed SIGNATURE_ value
1182
 
        """
1183
 
        if not self.has_signature_for_revision_id(revision_id):
1184
 
            return gpg.SIGNATURE_NOT_SIGNED, None
1185
 
        signature = self.get_signature_text(revision_id)
1186
 
 
1187
 
        testament = _mod_testament.Testament.from_revision(self, revision_id)
1188
 
        plaintext = testament.as_short_text()
1189
 
 
1190
 
        return gpg_strategy.verify(signature, plaintext)
1191
 
 
1192
888
    def has_signature_for_revision_id(self, revision_id):
1193
889
        """Query for a revision signature for revision_id in the repository."""
1194
 
        raise NotImplementedError(self.has_signature_for_revision_id)
 
890
        revision_id = osutils.safe_revision_id(revision_id)
 
891
        return self._revision_store.has_signature(revision_id,
 
892
                                                  self.get_transaction())
1195
893
 
 
894
    @needs_read_lock
1196
895
    def get_signature_text(self, revision_id):
1197
896
        """Return the text for a signature."""
1198
 
        raise NotImplementedError(self.get_signature_text)
 
897
        revision_id = osutils.safe_revision_id(revision_id)
 
898
        return self._revision_store.get_signature_text(revision_id,
 
899
                                                       self.get_transaction())
1199
900
 
1200
 
    def check(self, revision_ids=None, callback_refs=None, check_repo=True):
 
901
    @needs_read_lock
 
902
    def check(self, revision_ids):
1201
903
        """Check consistency of all history of given revision_ids.
1202
904
 
1203
905
        Different repository implementations should override _check().
1204
906
 
1205
907
        :param revision_ids: A non-empty list of revision_ids whose ancestry
1206
908
             will be checked.  Typically the last revision_id of a branch.
1207
 
        :param callback_refs: A dict of check-refs to resolve and callback
1208
 
            the check/_check method on the items listed as wanting the ref.
1209
 
            see bzrlib.check.
1210
 
        :param check_repo: If False do not check the repository contents, just 
1211
 
            calculate the data callback_refs requires and call them back.
1212
909
        """
1213
 
        return self._check(revision_ids=revision_ids, callback_refs=callback_refs,
1214
 
            check_repo=check_repo)
1215
 
 
1216
 
    def _check(self, revision_ids=None, callback_refs=None, check_repo=True):
1217
 
        raise NotImplementedError(self.check)
1218
 
 
1219
 
    def _warn_if_deprecated(self, branch=None):
1220
 
        if not self._format.is_deprecated():
1221
 
            return
 
910
        if not revision_ids:
 
911
            raise ValueError("revision_ids must be non-empty in %s.check" 
 
912
                    % (self,))
 
913
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
914
        return self._check(revision_ids)
 
915
 
 
916
    def _check(self, revision_ids):
 
917
        result = check.Check(self)
 
918
        result.check()
 
919
        return result
 
920
 
 
921
    def _warn_if_deprecated(self):
1222
922
        global _deprecation_warning_done
1223
923
        if _deprecation_warning_done:
1224
924
            return
1225
 
        try:
1226
 
            if branch is None:
1227
 
                conf = config.GlobalConfig()
1228
 
            else:
1229
 
                conf = branch.get_config()
1230
 
            if conf.suppress_warning('format_deprecation'):
1231
 
                return
1232
 
            warning("Format %s for %s is deprecated -"
1233
 
                    " please use 'bzr upgrade' to get better performance"
1234
 
                    % (self._format, self.bzrdir.transport.base))
1235
 
        finally:
1236
 
            _deprecation_warning_done = True
 
925
        _deprecation_warning_done = True
 
926
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
927
                % (self._format, self.bzrdir.transport.base))
1237
928
 
1238
929
    def supports_rich_root(self):
1239
930
        return self._format.rich_root_data
1255
946
                    raise errors.NonAsciiRevisionId(method, self)
1256
947
 
1257
948
 
 
949
 
 
950
# remove these delegates a while after bzr 0.15
 
951
def __make_delegated(name, from_module):
 
952
    def _deprecated_repository_forwarder():
 
953
        symbol_versioning.warn('%s moved to %s in bzr 0.15'
 
954
            % (name, from_module),
 
955
            DeprecationWarning,
 
956
            stacklevel=2)
 
957
        m = __import__(from_module, globals(), locals(), [name])
 
958
        try:
 
959
            return getattr(m, name)
 
960
        except AttributeError:
 
961
            raise AttributeError('module %s has no name %s'
 
962
                    % (m, name))
 
963
    globals()[name] = _deprecated_repository_forwarder
 
964
 
 
965
for _name in [
 
966
        'AllInOneRepository',
 
967
        'WeaveMetaDirRepository',
 
968
        'PreSplitOutRepositoryFormat',
 
969
        'RepositoryFormat4',
 
970
        'RepositoryFormat5',
 
971
        'RepositoryFormat6',
 
972
        'RepositoryFormat7',
 
973
        ]:
 
974
    __make_delegated(_name, 'bzrlib.repofmt.weaverepo')
 
975
 
 
976
for _name in [
 
977
        'KnitRepository',
 
978
        'RepositoryFormatKnit',
 
979
        'RepositoryFormatKnit1',
 
980
        ]:
 
981
    __make_delegated(_name, 'bzrlib.repofmt.knitrepo')
 
982
 
 
983
 
 
984
def install_revision(repository, rev, revision_tree):
 
985
    """Install all revision data into a repository."""
 
986
    present_parents = []
 
987
    parent_trees = {}
 
988
    for p_id in rev.parent_ids:
 
989
        if repository.has_revision(p_id):
 
990
            present_parents.append(p_id)
 
991
            parent_trees[p_id] = repository.revision_tree(p_id)
 
992
        else:
 
993
            parent_trees[p_id] = repository.revision_tree(None)
 
994
 
 
995
    inv = revision_tree.inventory
 
996
    entries = inv.iter_entries()
 
997
    # backwards compatability hack: skip the root id.
 
998
    if not repository.supports_rich_root():
 
999
        path, root = entries.next()
 
1000
        if root.revision != rev.revision_id:
 
1001
            raise errors.IncompatibleRevision(repr(repository))
 
1002
    # Add the texts that are not already present
 
1003
    for path, ie in entries:
 
1004
        w = repository.weave_store.get_weave_or_empty(ie.file_id,
 
1005
                repository.get_transaction())
 
1006
        if ie.revision not in w:
 
1007
            text_parents = []
 
1008
            # FIXME: TODO: The following loop *may* be overlapping/duplicate
 
1009
            # with InventoryEntry.find_previous_heads(). if it is, then there
 
1010
            # is a latent bug here where the parents may have ancestors of each
 
1011
            # other. RBC, AB
 
1012
            for revision, tree in parent_trees.iteritems():
 
1013
                if ie.file_id not in tree:
 
1014
                    continue
 
1015
                parent_id = tree.inventory[ie.file_id].revision
 
1016
                if parent_id in text_parents:
 
1017
                    continue
 
1018
                text_parents.append(parent_id)
 
1019
                    
 
1020
            vfile = repository.weave_store.get_weave_or_empty(ie.file_id, 
 
1021
                repository.get_transaction())
 
1022
            lines = revision_tree.get_file(ie.file_id).readlines()
 
1023
            vfile.add_lines(rev.revision_id, text_parents, lines)
 
1024
    try:
 
1025
        # install the inventory
 
1026
        repository.add_inventory(rev.revision_id, inv, present_parents)
 
1027
    except errors.RevisionAlreadyPresent:
 
1028
        pass
 
1029
    repository.add_revision(rev.revision_id, rev, inv)
 
1030
 
 
1031
 
1258
1032
class MetaDirRepository(Repository):
1259
 
    """Repositories in the new meta-dir layout.
1260
 
 
1261
 
    :ivar _transport: Transport for access to repository control files,
1262
 
        typically pointing to .bzr/repository.
1263
 
    """
1264
 
 
1265
 
    def __init__(self, _format, a_bzrdir, control_files):
1266
 
        super(MetaDirRepository, self).__init__(_format, a_bzrdir, control_files)
1267
 
        self._transport = control_files._transport
1268
 
 
 
1033
    """Repositories in the new meta-dir layout."""
 
1034
 
 
1035
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
 
1036
        super(MetaDirRepository, self).__init__(_format,
 
1037
                                                a_bzrdir,
 
1038
                                                control_files,
 
1039
                                                _revision_store,
 
1040
                                                control_store,
 
1041
                                                text_store)
 
1042
        dir_mode = self.control_files._dir_mode
 
1043
        file_mode = self.control_files._file_mode
 
1044
 
 
1045
    @needs_read_lock
1269
1046
    def is_shared(self):
1270
1047
        """Return True if this repository is flagged as a shared repository."""
1271
 
        return self._transport.has('shared-storage')
 
1048
        return self.control_files._transport.has('shared-storage')
1272
1049
 
1273
1050
    @needs_write_lock
1274
1051
    def set_make_working_trees(self, new_value):
1282
1059
        """
1283
1060
        if new_value:
1284
1061
            try:
1285
 
                self._transport.delete('no-working-trees')
 
1062
                self.control_files._transport.delete('no-working-trees')
1286
1063
            except errors.NoSuchFile:
1287
1064
                pass
1288
1065
        else:
1289
 
            self._transport.put_bytes('no-working-trees', '',
1290
 
                mode=self.bzrdir._get_file_mode())
1291
 
 
 
1066
            self.control_files.put_utf8('no-working-trees', '')
 
1067
    
1292
1068
    def make_working_trees(self):
1293
1069
        """Returns the policy for making working trees on new branches."""
1294
 
        return not self._transport.has('no-working-trees')
1295
 
 
1296
 
 
1297
 
class RepositoryFormatRegistry(controldir.ControlComponentFormatRegistry):
1298
 
    """Repository format registry."""
1299
 
 
1300
 
    def get_default(self):
1301
 
        """Return the current default format."""
1302
 
        return controldir.format_registry.make_bzrdir('default').repository_format
1303
 
 
1304
 
 
1305
 
network_format_registry = registry.FormatRegistry()
1306
 
"""Registry of formats indexed by their network name.
1307
 
 
1308
 
The network name for a repository format is an identifier that can be used when
1309
 
referring to formats with smart server operations. See
1310
 
RepositoryFormat.network_name() for more detail.
1311
 
"""
1312
 
 
1313
 
 
1314
 
format_registry = RepositoryFormatRegistry(network_format_registry)
1315
 
"""Registry of formats, indexed by their BzrDirMetaFormat format string.
 
1070
        return not self.control_files._transport.has('no-working-trees')
 
1071
 
 
1072
 
 
1073
class RepositoryFormatRegistry(registry.Registry):
 
1074
    """Registry of RepositoryFormats.
 
1075
    """
 
1076
 
 
1077
    def get(self, format_string):
 
1078
        r = registry.Registry.get(self, format_string)
 
1079
        if callable(r):
 
1080
            r = r()
 
1081
        return r
 
1082
    
 
1083
 
 
1084
format_registry = RepositoryFormatRegistry()
 
1085
"""Registry of formats, indexed by their identifying format string.
1316
1086
 
1317
1087
This can contain either format instances themselves, or classes/factories that
1318
1088
can be called to obtain one.
1322
1092
#####################################################################
1323
1093
# Repository Formats
1324
1094
 
1325
 
class RepositoryFormat(controldir.ControlComponentFormat):
 
1095
class RepositoryFormat(object):
1326
1096
    """A repository format.
1327
1097
 
1328
 
    Formats provide four things:
 
1098
    Formats provide three things:
1329
1099
     * An initialization routine to construct repository data on disk.
1330
 
     * a optional format string which is used when the BzrDir supports
1331
 
       versioned children.
 
1100
     * a format string which is used when the BzrDir supports versioned
 
1101
       children.
1332
1102
     * an open routine which returns a Repository instance.
1333
 
     * A network name for referring to the format in smart server RPC
1334
 
       methods.
1335
 
 
1336
 
    There is one and only one Format subclass for each on-disk format. But
1337
 
    there can be one Repository subclass that is used for several different
1338
 
    formats. The _format attribute on a Repository instance can be used to
1339
 
    determine the disk format.
1340
 
 
1341
 
    Formats are placed in a registry by their format string for reference
1342
 
    during opening. These should be subclasses of RepositoryFormat for
1343
 
    consistency.
 
1103
 
 
1104
    Formats are placed in an dict by their format string for reference 
 
1105
    during opening. These should be subclasses of RepositoryFormat
 
1106
    for consistency.
1344
1107
 
1345
1108
    Once a format is deprecated, just deprecate the initialize and open
1346
 
    methods on the format class. Do not deprecate the object, as the
1347
 
    object may be created even when a repository instance hasn't been
1348
 
    created.
 
1109
    methods on the format class. Do not deprecate the object, as the 
 
1110
    object will be created every system load.
1349
1111
 
1350
1112
    Common instance attributes:
1351
 
    _matchingbzrdir - the controldir format that the repository format was
 
1113
    _matchingbzrdir - the bzrdir format that the repository format was
1352
1114
    originally written to work with. This can be used if manually
1353
1115
    constructing a bzrdir and repository, or more commonly for test suite
1354
 
    parameterization.
 
1116
    parameterisation.
1355
1117
    """
1356
1118
 
1357
 
    # Set to True or False in derived classes. True indicates that the format
1358
 
    # supports ghosts gracefully.
1359
 
    supports_ghosts = None
1360
 
    # Can this repository be given external locations to lookup additional
1361
 
    # data. Set to True or False in derived classes.
1362
 
    supports_external_lookups = None
1363
 
    # Does this format support CHK bytestring lookups. Set to True or False in
1364
 
    # derived classes.
1365
 
    supports_chks = None
1366
 
    # Should fetch trigger a reconcile after the fetch? Only needed for
1367
 
    # some repository formats that can suffer internal inconsistencies.
1368
 
    _fetch_reconcile = False
1369
 
    # Does this format have < O(tree_size) delta generation. Used to hint what
1370
 
    # code path for commit, amongst other things.
1371
 
    fast_deltas = None
1372
 
    # Does doing a pack operation compress data? Useful for the pack UI command
1373
 
    # (so if there is one pack, the operation can still proceed because it may
1374
 
    # help), and for fetching when data won't have come from the same
1375
 
    # compressor.
1376
 
    pack_compresses = False
1377
 
    # Does the repository storage understand references to trees?
1378
 
    supports_tree_reference = None
1379
 
    # Is the format experimental ?
1380
 
    experimental = False
1381
 
    # Does this repository format escape funky characters, or does it create
1382
 
    # files with similar names as the versioned files in its contents on disk
1383
 
    # ?
1384
 
    supports_funky_characters = None
1385
 
    # Does this repository format support leaving locks?
1386
 
    supports_leaving_lock = None
1387
 
    # Does this format support the full VersionedFiles interface?
1388
 
    supports_full_versioned_files = None
1389
 
    # Does this format support signing revision signatures?
1390
 
    supports_revision_signatures = True
1391
 
    # Can the revision graph have incorrect parents?
1392
 
    revision_graph_can_have_wrong_parents = None
1393
 
    # Does this format support rich root data?
1394
 
    rich_root_data = None
1395
 
    # Does this format support explicitly versioned directories?
1396
 
    supports_versioned_directories = None
1397
 
    # Can other repositories be nested into one of this format?
1398
 
    supports_nesting_repositories = None
1399
 
    # Is it possible for revisions to be present without being referenced
1400
 
    # somewhere ?
1401
 
    supports_unreferenced_revisions = None
1402
 
 
1403
 
    def __repr__(self):
1404
 
        return "%s()" % self.__class__.__name__
 
1119
    def __str__(self):
 
1120
        return "<%s>" % self.__class__.__name__
1405
1121
 
1406
1122
    def __eq__(self, other):
1407
1123
        # format objects are generally stateless
1411
1127
        return not self == other
1412
1128
 
1413
1129
    @classmethod
1414
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
 
1130
    def find_format(klass, a_bzrdir):
 
1131
        """Return the format for the repository object in a_bzrdir.
 
1132
        
 
1133
        This is used by bzr native formats that have a "format" file in
 
1134
        the repository.  Other methods may be used by different types of 
 
1135
        control directory.
 
1136
        """
 
1137
        try:
 
1138
            transport = a_bzrdir.get_repository_transport(None)
 
1139
            format_string = transport.get("format").read()
 
1140
            return format_registry.get(format_string)
 
1141
        except errors.NoSuchFile:
 
1142
            raise errors.NoRepositoryPresent(a_bzrdir)
 
1143
        except KeyError:
 
1144
            raise errors.UnknownFormatError(format=format_string)
 
1145
 
 
1146
    @classmethod
1415
1147
    def register_format(klass, format):
1416
 
        format_registry.register(format)
 
1148
        format_registry.register(format.get_format_string(), format)
1417
1149
 
1418
1150
    @classmethod
1419
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1420
1151
    def unregister_format(klass, format):
1421
 
        format_registry.remove(format)
1422
 
 
 
1152
        format_registry.remove(format.get_format_string())
 
1153
    
1423
1154
    @classmethod
1424
 
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
1425
1155
    def get_default_format(klass):
1426
1156
        """Return the current default format."""
1427
 
        return format_registry.get_default()
 
1157
        from bzrlib import bzrdir
 
1158
        return bzrdir.format_registry.make_bzrdir('default').repository_format
 
1159
 
 
1160
    def _get_control_store(self, repo_transport, control_files):
 
1161
        """Return the control store for this repository."""
 
1162
        raise NotImplementedError(self._get_control_store)
 
1163
 
 
1164
    def get_format_string(self):
 
1165
        """Return the ASCII format string that identifies this format.
 
1166
        
 
1167
        Note that in pre format ?? repositories the format string is 
 
1168
        not permitted nor written to disk.
 
1169
        """
 
1170
        raise NotImplementedError(self.get_format_string)
1428
1171
 
1429
1172
    def get_format_description(self):
1430
1173
        """Return the short description for this format."""
1431
1174
        raise NotImplementedError(self.get_format_description)
1432
1175
 
1433
 
    def initialize(self, controldir, shared=False):
1434
 
        """Initialize a repository of this format in controldir.
1435
 
 
1436
 
        :param controldir: The controldir to put the new repository in it.
 
1176
    def _get_revision_store(self, repo_transport, control_files):
 
1177
        """Return the revision store object for this a_bzrdir."""
 
1178
        raise NotImplementedError(self._get_revision_store)
 
1179
 
 
1180
    def _get_text_rev_store(self,
 
1181
                            transport,
 
1182
                            control_files,
 
1183
                            name,
 
1184
                            compressed=True,
 
1185
                            prefixed=False,
 
1186
                            serializer=None):
 
1187
        """Common logic for getting a revision store for a repository.
 
1188
        
 
1189
        see self._get_revision_store for the subclass-overridable method to 
 
1190
        get the store for a repository.
 
1191
        """
 
1192
        from bzrlib.store.revision.text import TextRevisionStore
 
1193
        dir_mode = control_files._dir_mode
 
1194
        file_mode = control_files._file_mode
 
1195
        text_store = TextStore(transport.clone(name),
 
1196
                              prefixed=prefixed,
 
1197
                              compressed=compressed,
 
1198
                              dir_mode=dir_mode,
 
1199
                              file_mode=file_mode)
 
1200
        _revision_store = TextRevisionStore(text_store, serializer)
 
1201
        return _revision_store
 
1202
 
 
1203
    # TODO: this shouldn't be in the base class, it's specific to things that
 
1204
    # use weaves or knits -- mbp 20070207
 
1205
    def _get_versioned_file_store(self,
 
1206
                                  name,
 
1207
                                  transport,
 
1208
                                  control_files,
 
1209
                                  prefixed=True,
 
1210
                                  versionedfile_class=None,
 
1211
                                  versionedfile_kwargs={},
 
1212
                                  escaped=False):
 
1213
        if versionedfile_class is None:
 
1214
            versionedfile_class = self._versionedfile_class
 
1215
        weave_transport = control_files._transport.clone(name)
 
1216
        dir_mode = control_files._dir_mode
 
1217
        file_mode = control_files._file_mode
 
1218
        return VersionedFileStore(weave_transport, prefixed=prefixed,
 
1219
                                  dir_mode=dir_mode,
 
1220
                                  file_mode=file_mode,
 
1221
                                  versionedfile_class=versionedfile_class,
 
1222
                                  versionedfile_kwargs=versionedfile_kwargs,
 
1223
                                  escaped=escaped)
 
1224
 
 
1225
    def initialize(self, a_bzrdir, shared=False):
 
1226
        """Initialize a repository of this format in a_bzrdir.
 
1227
 
 
1228
        :param a_bzrdir: The bzrdir to put the new repository in it.
1437
1229
        :param shared: The repository should be initialized as a sharable one.
1438
1230
        :returns: The new repository object.
1439
 
 
 
1231
        
1440
1232
        This may raise UninitializableFormat if shared repository are not
1441
 
        compatible the controldir.
 
1233
        compatible the a_bzrdir.
1442
1234
        """
1443
1235
        raise NotImplementedError(self.initialize)
1444
1236
 
1446
1238
        """Is this format supported?
1447
1239
 
1448
1240
        Supported formats must be initializable and openable.
1449
 
        Unsupported formats may not support initialization or committing or
 
1241
        Unsupported formats may not support initialization or committing or 
1450
1242
        some other features depending on the reason for not being supported.
1451
1243
        """
1452
1244
        return True
1453
1245
 
1454
 
    def is_deprecated(self):
1455
 
        """Is this format deprecated?
1456
 
 
1457
 
        Deprecated formats may trigger a user-visible warning recommending
1458
 
        the user to upgrade. They are still fully supported.
1459
 
        """
1460
 
        return False
1461
 
 
1462
 
    def network_name(self):
1463
 
        """A simple byte string uniquely identifying this format for RPC calls.
1464
 
 
1465
 
        MetaDir repository formats use their disk format string to identify the
1466
 
        repository over the wire. All in one formats such as bzr < 0.8, and
1467
 
        foreign formats like svn/git and hg should use some marker which is
1468
 
        unique and immutable.
1469
 
        """
1470
 
        raise NotImplementedError(self.network_name)
1471
 
 
1472
1246
    def check_conversion_target(self, target_format):
1473
 
        if self.rich_root_data and not target_format.rich_root_data:
1474
 
            raise errors.BadConversionTarget(
1475
 
                'Does not support rich root data.', target_format,
1476
 
                from_format=self)
1477
 
        if (self.supports_tree_reference and 
1478
 
            not getattr(target_format, 'supports_tree_reference', False)):
1479
 
            raise errors.BadConversionTarget(
1480
 
                'Does not support nested trees', target_format,
1481
 
                from_format=self)
1482
 
 
1483
 
    def open(self, controldir, _found=False):
1484
 
        """Return an instance of this format for a controldir.
1485
 
 
 
1247
        raise NotImplementedError(self.check_conversion_target)
 
1248
 
 
1249
    def open(self, a_bzrdir, _found=False):
 
1250
        """Return an instance of this format for the bzrdir a_bzrdir.
 
1251
        
1486
1252
        _found is a private parameter, do not use it.
1487
1253
        """
1488
1254
        raise NotImplementedError(self.open)
1489
1255
 
1490
 
    def _run_post_repo_init_hooks(self, repository, controldir, shared):
1491
 
        from bzrlib.controldir import ControlDir, RepoInitHookParams
1492
 
        hooks = ControlDir.hooks['post_repo_init']
1493
 
        if not hooks:
1494
 
            return
1495
 
        params = RepoInitHookParams(repository, self, controldir, shared)
1496
 
        for hook in hooks:
1497
 
            hook(params)
1498
 
 
1499
 
 
1500
 
class RepositoryFormatMetaDir(bzrdir.BzrDirMetaComponentFormat, RepositoryFormat):
 
1256
 
 
1257
class MetaDirRepositoryFormat(RepositoryFormat):
1501
1258
    """Common base class for the new repositories using the metadir layout."""
1502
1259
 
1503
1260
    rich_root_data = False
1504
1261
    supports_tree_reference = False
1505
 
    supports_external_lookups = False
1506
 
    supports_leaving_lock = True
1507
 
    supports_nesting_repositories = True
1508
 
 
1509
 
    @property
1510
 
    def _matchingbzrdir(self):
1511
 
        matching = bzrdir.BzrDirMetaFormat1()
1512
 
        matching.repository_format = self
1513
 
        return matching
 
1262
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1514
1263
 
1515
1264
    def __init__(self):
1516
 
        RepositoryFormat.__init__(self)
1517
 
        bzrdir.BzrDirMetaComponentFormat.__init__(self)
 
1265
        super(MetaDirRepositoryFormat, self).__init__()
1518
1266
 
1519
1267
    def _create_control_files(self, a_bzrdir):
1520
1268
        """Create the required files and the initial control_files object."""
1530
1278
        """Upload the initial blank content."""
1531
1279
        control_files = self._create_control_files(a_bzrdir)
1532
1280
        control_files.lock_write()
1533
 
        transport = control_files._transport
1534
 
        if shared == True:
1535
 
            utf8_files += [('shared-storage', '')]
1536
1281
        try:
1537
 
            transport.mkdir_multi(dirs, mode=a_bzrdir._get_dir_mode())
1538
 
            for (filename, content_stream) in files:
1539
 
                transport.put_file(filename, content_stream,
1540
 
                    mode=a_bzrdir._get_file_mode())
1541
 
            for (filename, content_bytes) in utf8_files:
1542
 
                transport.put_bytes_non_atomic(filename, content_bytes,
1543
 
                    mode=a_bzrdir._get_file_mode())
 
1282
            control_files._transport.mkdir_multi(dirs,
 
1283
                    mode=control_files._dir_mode)
 
1284
            for file, content in files:
 
1285
                control_files.put(file, content)
 
1286
            for file, content in utf8_files:
 
1287
                control_files.put_utf8(file, content)
 
1288
            if shared == True:
 
1289
                control_files.put_utf8('shared-storage', '')
1544
1290
        finally:
1545
1291
            control_files.unlock()
1546
1292
 
1547
 
    @classmethod
1548
 
    def find_format(klass, a_bzrdir):
1549
 
        """Return the format for the repository object in a_bzrdir.
1550
 
 
1551
 
        This is used by bzr native formats that have a "format" file in
1552
 
        the repository.  Other methods may be used by different types of
1553
 
        control directory.
1554
 
        """
1555
 
        try:
1556
 
            transport = a_bzrdir.get_repository_transport(None)
1557
 
            format_string = transport.get_bytes("format")
1558
 
        except errors.NoSuchFile:
1559
 
            raise errors.NoRepositoryPresent(a_bzrdir)
1560
 
        return klass._find_format(format_registry, 'repository', format_string)
1561
 
 
1562
 
 
1563
 
# formats which have no format string are not discoverable or independently
1564
 
# creatable on disk, so are not registered in format_registry.  They're
1565
 
# all in bzrlib.repofmt.knitreponow.  When an instance of one of these is
1566
 
# needed, it's constructed directly by the ControlDir.  Non-native formats where
 
1293
 
 
1294
# formats which have no format string are not discoverable
 
1295
# and not independently creatable, so are not registered.  They're 
 
1296
# all in bzrlib.repofmt.weaverepo now.  When an instance of one of these is
 
1297
# needed, it's constructed directly by the BzrDir.  Non-native formats where
1567
1298
# the repository is not separately opened are similar.
1568
1299
 
1569
1300
format_registry.register_lazy(
 
1301
    'Bazaar-NG Repository format 7',
 
1302
    'bzrlib.repofmt.weaverepo',
 
1303
    'RepositoryFormat7'
 
1304
    )
 
1305
# KEEP in sync with bzrdir.format_registry default, which controls the overall
 
1306
# default control directory format
 
1307
 
 
1308
format_registry.register_lazy(
1570
1309
    'Bazaar-NG Knit Repository Format 1',
1571
1310
    'bzrlib.repofmt.knitrepo',
1572
1311
    'RepositoryFormatKnit1',
1573
1312
    )
 
1313
format_registry.default_key = 'Bazaar-NG Knit Repository Format 1'
1574
1314
 
1575
1315
format_registry.register_lazy(
1576
1316
    'Bazaar Knit Repository Format 3 (bzr 0.15)\n',
1578
1318
    'RepositoryFormatKnit3',
1579
1319
    )
1580
1320
 
1581
 
format_registry.register_lazy(
1582
 
    'Bazaar Knit Repository Format 4 (bzr 1.0)\n',
1583
 
    'bzrlib.repofmt.knitrepo',
1584
 
    'RepositoryFormatKnit4',
1585
 
    )
1586
 
 
1587
 
# Pack-based formats. There is one format for pre-subtrees, and one for
1588
 
# post-subtrees to allow ease of testing.
1589
 
# NOTE: These are experimental in 0.92. Stable in 1.0 and above
1590
 
format_registry.register_lazy(
1591
 
    'Bazaar pack repository format 1 (needs bzr 0.92)\n',
1592
 
    'bzrlib.repofmt.knitpack_repo',
1593
 
    'RepositoryFormatKnitPack1',
1594
 
    )
1595
 
format_registry.register_lazy(
1596
 
    'Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n',
1597
 
    'bzrlib.repofmt.knitpack_repo',
1598
 
    'RepositoryFormatKnitPack3',
1599
 
    )
1600
 
format_registry.register_lazy(
1601
 
    'Bazaar pack repository format 1 with rich root (needs bzr 1.0)\n',
1602
 
    'bzrlib.repofmt.knitpack_repo',
1603
 
    'RepositoryFormatKnitPack4',
1604
 
    )
1605
 
format_registry.register_lazy(
1606
 
    'Bazaar RepositoryFormatKnitPack5 (bzr 1.6)\n',
1607
 
    'bzrlib.repofmt.knitpack_repo',
1608
 
    'RepositoryFormatKnitPack5',
1609
 
    )
1610
 
format_registry.register_lazy(
1611
 
    'Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6.1)\n',
1612
 
    'bzrlib.repofmt.knitpack_repo',
1613
 
    'RepositoryFormatKnitPack5RichRoot',
1614
 
    )
1615
 
format_registry.register_lazy(
1616
 
    'Bazaar RepositoryFormatKnitPack5RichRoot (bzr 1.6)\n',
1617
 
    'bzrlib.repofmt.knitpack_repo',
1618
 
    'RepositoryFormatKnitPack5RichRootBroken',
1619
 
    )
1620
 
format_registry.register_lazy(
1621
 
    'Bazaar RepositoryFormatKnitPack6 (bzr 1.9)\n',
1622
 
    'bzrlib.repofmt.knitpack_repo',
1623
 
    'RepositoryFormatKnitPack6',
1624
 
    )
1625
 
format_registry.register_lazy(
1626
 
    'Bazaar RepositoryFormatKnitPack6RichRoot (bzr 1.9)\n',
1627
 
    'bzrlib.repofmt.knitpack_repo',
1628
 
    'RepositoryFormatKnitPack6RichRoot',
1629
 
    )
1630
 
format_registry.register_lazy(
1631
 
    'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
1632
 
    'bzrlib.repofmt.groupcompress_repo',
1633
 
    'RepositoryFormat2a',
1634
 
    )
1635
 
 
1636
 
# Development formats.
1637
 
# Check their docstrings to see if/when they are obsolete.
1638
 
format_registry.register_lazy(
1639
 
    ("Bazaar development format 2 with subtree support "
1640
 
        "(needs bzr.dev from before 1.8)\n"),
1641
 
    'bzrlib.repofmt.knitpack_repo',
1642
 
    'RepositoryFormatPackDevelopment2Subtree',
1643
 
    )
1644
 
format_registry.register_lazy(
1645
 
    'Bazaar development format 8\n',
1646
 
    'bzrlib.repofmt.groupcompress_repo',
1647
 
    'RepositoryFormat2aSubtree',
1648
 
    )
1649
 
 
1650
1321
 
1651
1322
class InterRepository(InterObject):
1652
1323
    """This class represents operations taking place between two repositories.
1653
1324
 
1654
1325
    Its instances have methods like copy_content and fetch, and contain
1655
 
    references to the source and target repositories these operations can be
 
1326
    references to the source and target repositories these operations can be 
1656
1327
    carried out on.
1657
1328
 
1658
1329
    Often we will provide convenience methods on 'repository' which carry out
1663
1334
    _optimisers = []
1664
1335
    """The available optimised InterRepository types."""
1665
1336
 
1666
 
    @needs_write_lock
1667
1337
    def copy_content(self, revision_id=None):
1668
 
        """Make a complete copy of the content in self into destination.
1669
 
 
1670
 
        This is a destructive operation! Do not use it on existing
1671
 
        repositories.
1672
 
 
1673
 
        :param revision_id: Only copy the content needed to construct
1674
 
                            revision_id and its parents.
1675
 
        """
1676
 
        try:
1677
 
            self.target.set_make_working_trees(self.source.make_working_trees())
1678
 
        except NotImplementedError:
1679
 
            pass
1680
 
        self.target.fetch(self.source, revision_id=revision_id)
1681
 
 
1682
 
    @needs_write_lock
1683
 
    def fetch(self, revision_id=None, find_ghosts=False):
 
1338
        raise NotImplementedError(self.copy_content)
 
1339
 
 
1340
    def fetch(self, revision_id=None, pb=None):
1684
1341
        """Fetch the content required to construct revision_id.
1685
1342
 
1686
1343
        The content is copied from self.source to self.target.
1687
1344
 
1688
1345
        :param revision_id: if None all content is copied, if NULL_REVISION no
1689
1346
                            content is copied.
1690
 
        :return: None.
 
1347
        :param pb: optional progress bar to use for progress reports. If not
 
1348
                   provided a default one will be created.
 
1349
 
 
1350
        Returns the copied revision count and the failed revisions in a tuple:
 
1351
        (copied, failures).
1691
1352
        """
1692
1353
        raise NotImplementedError(self.fetch)
1693
 
 
 
1354
   
1694
1355
    @needs_read_lock
1695
 
    def search_missing_revision_ids(self,
1696
 
            revision_id=symbol_versioning.DEPRECATED_PARAMETER,
1697
 
            find_ghosts=True, revision_ids=None, if_present_ids=None,
1698
 
            limit=None):
 
1356
    def missing_revision_ids(self, revision_id=None):
1699
1357
        """Return the revision ids that source has that target does not.
 
1358
        
 
1359
        These are returned in topological order.
1700
1360
 
1701
1361
        :param revision_id: only return revision ids included by this
1702
 
            revision_id.
1703
 
        :param revision_ids: return revision ids included by these
1704
 
            revision_ids.  NoSuchRevision will be raised if any of these
1705
 
            revisions are not present.
1706
 
        :param if_present_ids: like revision_ids, but will not cause
1707
 
            NoSuchRevision if any of these are absent, instead they will simply
1708
 
            not be in the result.  This is useful for e.g. finding revisions
1709
 
            to fetch for tags, which may reference absent revisions.
1710
 
        :param find_ghosts: If True find missing revisions in deep history
1711
 
            rather than just finding the surface difference.
1712
 
        :param limit: Maximum number of revisions to return, topologically
1713
 
            ordered
1714
 
        :return: A bzrlib.graph.SearchResult.
1715
 
        """
1716
 
        raise NotImplementedError(self.search_missing_revision_ids)
1717
 
 
1718
 
    @staticmethod
1719
 
    def _same_model(source, target):
1720
 
        """True if source and target have the same data representation.
1721
 
 
1722
 
        Note: this is always called on the base class; overriding it in a
1723
 
        subclass will have no effect.
1724
 
        """
1725
 
        try:
1726
 
            InterRepository._assert_same_model(source, target)
1727
 
            return True
1728
 
        except errors.IncompatibleRepositories, e:
1729
 
            return False
1730
 
 
1731
 
    @staticmethod
1732
 
    def _assert_same_model(source, target):
1733
 
        """Raise an exception if two repositories do not use the same model.
1734
 
        """
 
1362
                            revision_id.
 
1363
        """
 
1364
        # generic, possibly worst case, slow code path.
 
1365
        target_ids = set(self.target.all_revision_ids())
 
1366
        if revision_id is not None:
 
1367
            # TODO: jam 20070210 InterRepository is internal enough that it
 
1368
            #       should assume revision_ids are already utf-8
 
1369
            revision_id = osutils.safe_revision_id(revision_id)
 
1370
            source_ids = self.source.get_ancestry(revision_id)
 
1371
            assert source_ids[0] is None
 
1372
            source_ids.pop(0)
 
1373
        else:
 
1374
            source_ids = self.source.all_revision_ids()
 
1375
        result_set = set(source_ids).difference(target_ids)
 
1376
        # this may look like a no-op: its not. It preserves the ordering
 
1377
        # other_ids had while only returning the members from other_ids
 
1378
        # that we've decided we need.
 
1379
        return [rev_id for rev_id in source_ids if rev_id in result_set]
 
1380
 
 
1381
 
 
1382
class InterSameDataRepository(InterRepository):
 
1383
    """Code for converting between repositories that represent the same data.
 
1384
    
 
1385
    Data format and model must match for this to work.
 
1386
    """
 
1387
 
 
1388
    @classmethod
 
1389
    def _get_repo_format_to_test(self):
 
1390
        """Repository format for testing with."""
 
1391
        return RepositoryFormat.get_default_format()
 
1392
 
 
1393
    @staticmethod
 
1394
    def is_compatible(source, target):
1735
1395
        if source.supports_rich_root() != target.supports_rich_root():
1736
 
            raise errors.IncompatibleRepositories(source, target,
1737
 
                "different rich-root support")
 
1396
            return False
1738
1397
        if source._serializer != target._serializer:
1739
 
            raise errors.IncompatibleRepositories(source, target,
1740
 
                "different serializers")
 
1398
            return False
 
1399
        return True
 
1400
 
 
1401
    @needs_write_lock
 
1402
    def copy_content(self, revision_id=None):
 
1403
        """Make a complete copy of the content in self into destination.
 
1404
 
 
1405
        This copies both the repository's revision data, and configuration information
 
1406
        such as the make_working_trees setting.
 
1407
        
 
1408
        This is a destructive operation! Do not use it on existing 
 
1409
        repositories.
 
1410
 
 
1411
        :param revision_id: Only copy the content needed to construct
 
1412
                            revision_id and its parents.
 
1413
        """
 
1414
        try:
 
1415
            self.target.set_make_working_trees(self.source.make_working_trees())
 
1416
        except NotImplementedError:
 
1417
            pass
 
1418
        # TODO: jam 20070210 This is fairly internal, so we should probably
 
1419
        #       just assert that revision_id is not unicode.
 
1420
        revision_id = osutils.safe_revision_id(revision_id)
 
1421
        # but don't bother fetching if we have the needed data now.
 
1422
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
1423
            self.target.has_revision(revision_id)):
 
1424
            return
 
1425
        self.target.fetch(self.source, revision_id=revision_id)
 
1426
 
 
1427
    @needs_write_lock
 
1428
    def fetch(self, revision_id=None, pb=None):
 
1429
        """See InterRepository.fetch()."""
 
1430
        from bzrlib.fetch import GenericRepoFetcher
 
1431
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1432
               self.source, self.source._format, self.target, 
 
1433
               self.target._format)
 
1434
        # TODO: jam 20070210 This should be an assert, not a translate
 
1435
        revision_id = osutils.safe_revision_id(revision_id)
 
1436
        f = GenericRepoFetcher(to_repository=self.target,
 
1437
                               from_repository=self.source,
 
1438
                               last_revision=revision_id,
 
1439
                               pb=pb)
 
1440
        return f.count_copied, f.failed_revisions
 
1441
 
 
1442
 
 
1443
class InterWeaveRepo(InterSameDataRepository):
 
1444
    """Optimised code paths between Weave based repositories."""
 
1445
 
 
1446
    @classmethod
 
1447
    def _get_repo_format_to_test(self):
 
1448
        from bzrlib.repofmt import weaverepo
 
1449
        return weaverepo.RepositoryFormat7()
 
1450
 
 
1451
    @staticmethod
 
1452
    def is_compatible(source, target):
 
1453
        """Be compatible with known Weave formats.
 
1454
        
 
1455
        We don't test for the stores being of specific types because that
 
1456
        could lead to confusing results, and there is no need to be 
 
1457
        overly general.
 
1458
        """
 
1459
        from bzrlib.repofmt.weaverepo import (
 
1460
                RepositoryFormat5,
 
1461
                RepositoryFormat6,
 
1462
                RepositoryFormat7,
 
1463
                )
 
1464
        try:
 
1465
            return (isinstance(source._format, (RepositoryFormat5,
 
1466
                                                RepositoryFormat6,
 
1467
                                                RepositoryFormat7)) and
 
1468
                    isinstance(target._format, (RepositoryFormat5,
 
1469
                                                RepositoryFormat6,
 
1470
                                                RepositoryFormat7)))
 
1471
        except AttributeError:
 
1472
            return False
 
1473
    
 
1474
    @needs_write_lock
 
1475
    def copy_content(self, revision_id=None):
 
1476
        """See InterRepository.copy_content()."""
 
1477
        # weave specific optimised path:
 
1478
        # TODO: jam 20070210 Internal, should be an assert, not translate
 
1479
        revision_id = osutils.safe_revision_id(revision_id)
 
1480
        try:
 
1481
            self.target.set_make_working_trees(self.source.make_working_trees())
 
1482
        except NotImplementedError:
 
1483
            pass
 
1484
        # FIXME do not peek!
 
1485
        if self.source.control_files._transport.listable():
 
1486
            pb = ui.ui_factory.nested_progress_bar()
 
1487
            try:
 
1488
                self.target.weave_store.copy_all_ids(
 
1489
                    self.source.weave_store,
 
1490
                    pb=pb,
 
1491
                    from_transaction=self.source.get_transaction(),
 
1492
                    to_transaction=self.target.get_transaction())
 
1493
                pb.update('copying inventory', 0, 1)
 
1494
                self.target.control_weaves.copy_multi(
 
1495
                    self.source.control_weaves, ['inventory'],
 
1496
                    from_transaction=self.source.get_transaction(),
 
1497
                    to_transaction=self.target.get_transaction())
 
1498
                self.target._revision_store.text_store.copy_all_ids(
 
1499
                    self.source._revision_store.text_store,
 
1500
                    pb=pb)
 
1501
            finally:
 
1502
                pb.finished()
 
1503
        else:
 
1504
            self.target.fetch(self.source, revision_id=revision_id)
 
1505
 
 
1506
    @needs_write_lock
 
1507
    def fetch(self, revision_id=None, pb=None):
 
1508
        """See InterRepository.fetch()."""
 
1509
        from bzrlib.fetch import GenericRepoFetcher
 
1510
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1511
               self.source, self.source._format, self.target, self.target._format)
 
1512
        # TODO: jam 20070210 This should be an assert, not a translate
 
1513
        revision_id = osutils.safe_revision_id(revision_id)
 
1514
        f = GenericRepoFetcher(to_repository=self.target,
 
1515
                               from_repository=self.source,
 
1516
                               last_revision=revision_id,
 
1517
                               pb=pb)
 
1518
        return f.count_copied, f.failed_revisions
 
1519
 
 
1520
    @needs_read_lock
 
1521
    def missing_revision_ids(self, revision_id=None):
 
1522
        """See InterRepository.missing_revision_ids()."""
 
1523
        # we want all revisions to satisfy revision_id in source.
 
1524
        # but we don't want to stat every file here and there.
 
1525
        # we want then, all revisions other needs to satisfy revision_id 
 
1526
        # checked, but not those that we have locally.
 
1527
        # so the first thing is to get a subset of the revisions to 
 
1528
        # satisfy revision_id in source, and then eliminate those that
 
1529
        # we do already have. 
 
1530
        # this is slow on high latency connection to self, but as as this
 
1531
        # disk format scales terribly for push anyway due to rewriting 
 
1532
        # inventory.weave, this is considered acceptable.
 
1533
        # - RBC 20060209
 
1534
        if revision_id is not None:
 
1535
            source_ids = self.source.get_ancestry(revision_id)
 
1536
            assert source_ids[0] is None
 
1537
            source_ids.pop(0)
 
1538
        else:
 
1539
            source_ids = self.source._all_possible_ids()
 
1540
        source_ids_set = set(source_ids)
 
1541
        # source_ids is the worst possible case we may need to pull.
 
1542
        # now we want to filter source_ids against what we actually
 
1543
        # have in target, but don't try to check for existence where we know
 
1544
        # we do not have a revision as that would be pointless.
 
1545
        target_ids = set(self.target._all_possible_ids())
 
1546
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
1547
        actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
1548
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
1549
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
 
1550
        if revision_id is not None:
 
1551
            # we used get_ancestry to determine source_ids then we are assured all
 
1552
            # revisions referenced are present as they are installed in topological order.
 
1553
            # and the tip revision was validated by get_ancestry.
 
1554
            return required_topo_revisions
 
1555
        else:
 
1556
            # if we just grabbed the possibly available ids, then 
 
1557
            # we only have an estimate of whats available and need to validate
 
1558
            # that against the revision records.
 
1559
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
 
1560
 
 
1561
 
 
1562
class InterKnitRepo(InterSameDataRepository):
 
1563
    """Optimised code paths between Knit based repositories."""
 
1564
 
 
1565
    @classmethod
 
1566
    def _get_repo_format_to_test(self):
 
1567
        from bzrlib.repofmt import knitrepo
 
1568
        return knitrepo.RepositoryFormatKnit1()
 
1569
 
 
1570
    @staticmethod
 
1571
    def is_compatible(source, target):
 
1572
        """Be compatible with known Knit formats.
 
1573
        
 
1574
        We don't test for the stores being of specific types because that
 
1575
        could lead to confusing results, and there is no need to be 
 
1576
        overly general.
 
1577
        """
 
1578
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1
 
1579
        try:
 
1580
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
 
1581
                    isinstance(target._format, (RepositoryFormatKnit1)))
 
1582
        except AttributeError:
 
1583
            return False
 
1584
 
 
1585
    @needs_write_lock
 
1586
    def fetch(self, revision_id=None, pb=None):
 
1587
        """See InterRepository.fetch()."""
 
1588
        from bzrlib.fetch import KnitRepoFetcher
 
1589
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1590
               self.source, self.source._format, self.target, self.target._format)
 
1591
        # TODO: jam 20070210 This should be an assert, not a translate
 
1592
        revision_id = osutils.safe_revision_id(revision_id)
 
1593
        f = KnitRepoFetcher(to_repository=self.target,
 
1594
                            from_repository=self.source,
 
1595
                            last_revision=revision_id,
 
1596
                            pb=pb)
 
1597
        return f.count_copied, f.failed_revisions
 
1598
 
 
1599
    @needs_read_lock
 
1600
    def missing_revision_ids(self, revision_id=None):
 
1601
        """See InterRepository.missing_revision_ids()."""
 
1602
        if revision_id is not None:
 
1603
            source_ids = self.source.get_ancestry(revision_id)
 
1604
            assert source_ids[0] is None
 
1605
            source_ids.pop(0)
 
1606
        else:
 
1607
            source_ids = self.source._all_possible_ids()
 
1608
        source_ids_set = set(source_ids)
 
1609
        # source_ids is the worst possible case we may need to pull.
 
1610
        # now we want to filter source_ids against what we actually
 
1611
        # have in target, but don't try to check for existence where we know
 
1612
        # we do not have a revision as that would be pointless.
 
1613
        target_ids = set(self.target._all_possible_ids())
 
1614
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
1615
        actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
1616
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
1617
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
 
1618
        if revision_id is not None:
 
1619
            # we used get_ancestry to determine source_ids then we are assured all
 
1620
            # revisions referenced are present as they are installed in topological order.
 
1621
            # and the tip revision was validated by get_ancestry.
 
1622
            return required_topo_revisions
 
1623
        else:
 
1624
            # if we just grabbed the possibly available ids, then 
 
1625
            # we only have an estimate of whats available and need to validate
 
1626
            # that against the revision records.
 
1627
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
 
1628
 
 
1629
 
 
1630
class InterModel1and2(InterRepository):
 
1631
 
 
1632
    @classmethod
 
1633
    def _get_repo_format_to_test(self):
 
1634
        return None
 
1635
 
 
1636
    @staticmethod
 
1637
    def is_compatible(source, target):
 
1638
        if not source.supports_rich_root() and target.supports_rich_root():
 
1639
            return True
 
1640
        else:
 
1641
            return False
 
1642
 
 
1643
    @needs_write_lock
 
1644
    def fetch(self, revision_id=None, pb=None):
 
1645
        """See InterRepository.fetch()."""
 
1646
        from bzrlib.fetch import Model1toKnit2Fetcher
 
1647
        # TODO: jam 20070210 This should be an assert, not a translate
 
1648
        revision_id = osutils.safe_revision_id(revision_id)
 
1649
        f = Model1toKnit2Fetcher(to_repository=self.target,
 
1650
                                 from_repository=self.source,
 
1651
                                 last_revision=revision_id,
 
1652
                                 pb=pb)
 
1653
        return f.count_copied, f.failed_revisions
 
1654
 
 
1655
    @needs_write_lock
 
1656
    def copy_content(self, revision_id=None):
 
1657
        """Make a complete copy of the content in self into destination.
 
1658
        
 
1659
        This is a destructive operation! Do not use it on existing 
 
1660
        repositories.
 
1661
 
 
1662
        :param revision_id: Only copy the content needed to construct
 
1663
                            revision_id and its parents.
 
1664
        """
 
1665
        try:
 
1666
            self.target.set_make_working_trees(self.source.make_working_trees())
 
1667
        except NotImplementedError:
 
1668
            pass
 
1669
        # TODO: jam 20070210 Internal, assert, don't translate
 
1670
        revision_id = osutils.safe_revision_id(revision_id)
 
1671
        # but don't bother fetching if we have the needed data now.
 
1672
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
1673
            self.target.has_revision(revision_id)):
 
1674
            return
 
1675
        self.target.fetch(self.source, revision_id=revision_id)
 
1676
 
 
1677
 
 
1678
class InterKnit1and2(InterKnitRepo):
 
1679
 
 
1680
    @classmethod
 
1681
    def _get_repo_format_to_test(self):
 
1682
        return None
 
1683
 
 
1684
    @staticmethod
 
1685
    def is_compatible(source, target):
 
1686
        """Be compatible with Knit1 source and Knit3 target"""
 
1687
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit3
 
1688
        try:
 
1689
            from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1, \
 
1690
                    RepositoryFormatKnit3
 
1691
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
 
1692
                    isinstance(target._format, (RepositoryFormatKnit3)))
 
1693
        except AttributeError:
 
1694
            return False
 
1695
 
 
1696
    @needs_write_lock
 
1697
    def fetch(self, revision_id=None, pb=None):
 
1698
        """See InterRepository.fetch()."""
 
1699
        from bzrlib.fetch import Knit1to2Fetcher
 
1700
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1701
               self.source, self.source._format, self.target, 
 
1702
               self.target._format)
 
1703
        # TODO: jam 20070210 This should be an assert, not a translate
 
1704
        revision_id = osutils.safe_revision_id(revision_id)
 
1705
        f = Knit1to2Fetcher(to_repository=self.target,
 
1706
                            from_repository=self.source,
 
1707
                            last_revision=revision_id,
 
1708
                            pb=pb)
 
1709
        return f.count_copied, f.failed_revisions
 
1710
 
 
1711
 
 
1712
class InterRemoteRepository(InterRepository):
 
1713
    """Code for converting between RemoteRepository objects.
 
1714
 
 
1715
    This just gets an non-remote repository from the RemoteRepository, and calls
 
1716
    InterRepository.get again.
 
1717
    """
 
1718
 
 
1719
    def __init__(self, source, target):
 
1720
        if isinstance(source, remote.RemoteRepository):
 
1721
            source._ensure_real()
 
1722
            real_source = source._real_repository
 
1723
        else:
 
1724
            real_source = source
 
1725
        if isinstance(target, remote.RemoteRepository):
 
1726
            target._ensure_real()
 
1727
            real_target = target._real_repository
 
1728
        else:
 
1729
            real_target = target
 
1730
        self.real_inter = InterRepository.get(real_source, real_target)
 
1731
 
 
1732
    @staticmethod
 
1733
    def is_compatible(source, target):
 
1734
        if isinstance(source, remote.RemoteRepository):
 
1735
            return True
 
1736
        if isinstance(target, remote.RemoteRepository):
 
1737
            return True
 
1738
        return False
 
1739
 
 
1740
    def copy_content(self, revision_id=None):
 
1741
        self.real_inter.copy_content(revision_id=revision_id)
 
1742
 
 
1743
    def fetch(self, revision_id=None, pb=None):
 
1744
        self.real_inter.fetch(revision_id=revision_id, pb=pb)
 
1745
 
 
1746
    @classmethod
 
1747
    def _get_repo_format_to_test(self):
 
1748
        return None
 
1749
 
 
1750
 
 
1751
InterRepository.register_optimiser(InterSameDataRepository)
 
1752
InterRepository.register_optimiser(InterWeaveRepo)
 
1753
InterRepository.register_optimiser(InterKnitRepo)
 
1754
InterRepository.register_optimiser(InterModel1and2)
 
1755
InterRepository.register_optimiser(InterKnit1and2)
 
1756
InterRepository.register_optimiser(InterRemoteRepository)
 
1757
 
 
1758
 
 
1759
class RepositoryTestProviderAdapter(object):
 
1760
    """A tool to generate a suite testing multiple repository formats at once.
 
1761
 
 
1762
    This is done by copying the test once for each transport and injecting
 
1763
    the transport_server, transport_readonly_server, and bzrdir_format and
 
1764
    repository_format classes into each copy. Each copy is also given a new id()
 
1765
    to make it easy to identify.
 
1766
    """
 
1767
 
 
1768
    def __init__(self, transport_server, transport_readonly_server, formats,
 
1769
                 vfs_transport_factory=None):
 
1770
        self._transport_server = transport_server
 
1771
        self._transport_readonly_server = transport_readonly_server
 
1772
        self._vfs_transport_factory = vfs_transport_factory
 
1773
        self._formats = formats
 
1774
    
 
1775
    def adapt(self, test):
 
1776
        result = unittest.TestSuite()
 
1777
        for repository_format, bzrdir_format in self._formats:
 
1778
            from copy import deepcopy
 
1779
            new_test = deepcopy(test)
 
1780
            new_test.transport_server = self._transport_server
 
1781
            new_test.transport_readonly_server = self._transport_readonly_server
 
1782
            # Only override the test's vfs_transport_factory if one was
 
1783
            # specified, otherwise just leave the default in place.
 
1784
            if self._vfs_transport_factory:
 
1785
                new_test.vfs_transport_factory = self._vfs_transport_factory
 
1786
            new_test.bzrdir_format = bzrdir_format
 
1787
            new_test.repository_format = repository_format
 
1788
            def make_new_test_id():
 
1789
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
 
1790
                return lambda: new_id
 
1791
            new_test.id = make_new_test_id()
 
1792
            result.addTest(new_test)
 
1793
        return result
 
1794
 
 
1795
 
 
1796
class InterRepositoryTestProviderAdapter(object):
 
1797
    """A tool to generate a suite testing multiple inter repository formats.
 
1798
 
 
1799
    This is done by copying the test once for each interrepo provider and injecting
 
1800
    the transport_server, transport_readonly_server, repository_format and 
 
1801
    repository_to_format classes into each copy.
 
1802
    Each copy is also given a new id() to make it easy to identify.
 
1803
    """
 
1804
 
 
1805
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1806
        self._transport_server = transport_server
 
1807
        self._transport_readonly_server = transport_readonly_server
 
1808
        self._formats = formats
 
1809
    
 
1810
    def adapt(self, test):
 
1811
        result = unittest.TestSuite()
 
1812
        for interrepo_class, repository_format, repository_format_to in self._formats:
 
1813
            from copy import deepcopy
 
1814
            new_test = deepcopy(test)
 
1815
            new_test.transport_server = self._transport_server
 
1816
            new_test.transport_readonly_server = self._transport_readonly_server
 
1817
            new_test.interrepo_class = interrepo_class
 
1818
            new_test.repository_format = repository_format
 
1819
            new_test.repository_format_to = repository_format_to
 
1820
            def make_new_test_id():
 
1821
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
 
1822
                return lambda: new_id
 
1823
            new_test.id = make_new_test_id()
 
1824
            result.addTest(new_test)
 
1825
        return result
 
1826
 
 
1827
    @staticmethod
 
1828
    def default_test_list():
 
1829
        """Generate the default list of interrepo permutations to test."""
 
1830
        from bzrlib.repofmt import knitrepo, weaverepo
 
1831
        result = []
 
1832
        # test the default InterRepository between format 6 and the current 
 
1833
        # default format.
 
1834
        # XXX: robertc 20060220 reinstate this when there are two supported
 
1835
        # formats which do not have an optimal code path between them.
 
1836
        #result.append((InterRepository,
 
1837
        #               RepositoryFormat6(),
 
1838
        #               RepositoryFormatKnit1()))
 
1839
        for optimiser_class in InterRepository._optimisers:
 
1840
            format_to_test = optimiser_class._get_repo_format_to_test()
 
1841
            if format_to_test is not None:
 
1842
                result.append((optimiser_class,
 
1843
                               format_to_test, format_to_test))
 
1844
        # if there are specific combinations we want to use, we can add them 
 
1845
        # here.
 
1846
        result.append((InterModel1and2,
 
1847
                       weaverepo.RepositoryFormat5(),
 
1848
                       knitrepo.RepositoryFormatKnit3()))
 
1849
        result.append((InterKnit1and2,
 
1850
                       knitrepo.RepositoryFormatKnit1(),
 
1851
                       knitrepo.RepositoryFormatKnit3()))
 
1852
        return result
1741
1853
 
1742
1854
 
1743
1855
class CopyConverter(object):
1744
1856
    """A repository conversion tool which just performs a copy of the content.
1745
 
 
 
1857
    
1746
1858
    This is slow but quite reliable.
1747
1859
    """
1748
1860
 
1752
1864
        :param target_format: The format the resulting repository should be.
1753
1865
        """
1754
1866
        self.target_format = target_format
1755
 
 
 
1867
        
1756
1868
    def convert(self, repo, pb):
1757
1869
        """Perform the conversion of to_convert, giving feedback via pb.
1758
1870
 
1759
1871
        :param to_convert: The disk object to convert.
1760
1872
        :param pb: a progress bar to use for progress information.
1761
1873
        """
1762
 
        pb = ui.ui_factory.nested_progress_bar()
 
1874
        self.pb = pb
1763
1875
        self.count = 0
1764
1876
        self.total = 4
1765
1877
        # this is only useful with metadir layouts - separated repo content.
1766
1878
        # trigger an assertion if not such
1767
1879
        repo._format.get_format_string()
1768
1880
        self.repo_dir = repo.bzrdir
1769
 
        pb.update(gettext('Moving repository to repository.backup'))
 
1881
        self.step('Moving repository to repository.backup')
1770
1882
        self.repo_dir.transport.move('repository', 'repository.backup')
1771
1883
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
1772
1884
        repo._format.check_conversion_target(self.target_format)
1773
1885
        self.source_repo = repo._format.open(self.repo_dir,
1774
1886
            _found=True,
1775
1887
            _override_transport=backup_transport)
1776
 
        pb.update(gettext('Creating new repository'))
 
1888
        self.step('Creating new repository')
1777
1889
        converted = self.target_format.initialize(self.repo_dir,
1778
1890
                                                  self.source_repo.is_shared())
1779
1891
        converted.lock_write()
1780
1892
        try:
1781
 
            pb.update(gettext('Copying content'))
 
1893
            self.step('Copying content into repository.')
1782
1894
            self.source_repo.copy_content_into(converted)
1783
1895
        finally:
1784
1896
            converted.unlock()
1785
 
        pb.update(gettext('Deleting old repository content'))
 
1897
        self.step('Deleting old repository content.')
1786
1898
        self.repo_dir.transport.delete_tree('repository.backup')
1787
 
        ui.ui_factory.note(gettext('repository converted'))
1788
 
        pb.finished()
1789
 
 
1790
 
 
1791
 
def _strip_NULL_ghosts(revision_graph):
1792
 
    """Also don't use this. more compatibility code for unmigrated clients."""
1793
 
    # Filter ghosts, and null:
1794
 
    if _mod_revision.NULL_REVISION in revision_graph:
1795
 
        del revision_graph[_mod_revision.NULL_REVISION]
1796
 
    for key, parents in revision_graph.items():
1797
 
        revision_graph[key] = tuple(parent for parent in parents if parent
1798
 
            in revision_graph)
1799
 
    return revision_graph
1800
 
 
1801
 
 
1802
 
def _iter_for_revno(repo, partial_history_cache, stop_index=None,
1803
 
                    stop_revision=None):
1804
 
    """Extend the partial history to include a given index
1805
 
 
1806
 
    If a stop_index is supplied, stop when that index has been reached.
1807
 
    If a stop_revision is supplied, stop when that revision is
1808
 
    encountered.  Otherwise, stop when the beginning of history is
1809
 
    reached.
1810
 
 
1811
 
    :param stop_index: The index which should be present.  When it is
1812
 
        present, history extension will stop.
1813
 
    :param stop_revision: The revision id which should be present.  When
1814
 
        it is encountered, history extension will stop.
1815
 
    """
1816
 
    start_revision = partial_history_cache[-1]
1817
 
    graph = repo.get_graph()
1818
 
    iterator = graph.iter_lefthand_ancestry(start_revision,
1819
 
        (_mod_revision.NULL_REVISION,))
 
1899
        self.pb.note('repository converted')
 
1900
 
 
1901
    def step(self, message):
 
1902
        """Update the pb by a step."""
 
1903
        self.count +=1
 
1904
        self.pb.update(message, self.count, self.total)
 
1905
 
 
1906
 
 
1907
class CommitBuilder(object):
 
1908
    """Provides an interface to build up a commit.
 
1909
 
 
1910
    This allows describing a tree to be committed without needing to 
 
1911
    know the internals of the format of the repository.
 
1912
    """
 
1913
    
 
1914
    record_root_entry = False
 
1915
    def __init__(self, repository, parents, config, timestamp=None, 
 
1916
                 timezone=None, committer=None, revprops=None, 
 
1917
                 revision_id=None):
 
1918
        """Initiate a CommitBuilder.
 
1919
 
 
1920
        :param repository: Repository to commit to.
 
1921
        :param parents: Revision ids of the parents of the new revision.
 
1922
        :param config: Configuration to use.
 
1923
        :param timestamp: Optional timestamp recorded for commit.
 
1924
        :param timezone: Optional timezone for timestamp.
 
1925
        :param committer: Optional committer to set for commit.
 
1926
        :param revprops: Optional dictionary of revision properties.
 
1927
        :param revision_id: Optional revision id.
 
1928
        """
 
1929
        self._config = config
 
1930
 
 
1931
        if committer is None:
 
1932
            self._committer = self._config.username()
 
1933
        else:
 
1934
            assert isinstance(committer, basestring), type(committer)
 
1935
            self._committer = committer
 
1936
 
 
1937
        self.new_inventory = Inventory(None)
 
1938
        self._new_revision_id = osutils.safe_revision_id(revision_id)
 
1939
        self.parents = parents
 
1940
        self.repository = repository
 
1941
 
 
1942
        self._revprops = {}
 
1943
        if revprops is not None:
 
1944
            self._revprops.update(revprops)
 
1945
 
 
1946
        if timestamp is None:
 
1947
            timestamp = time.time()
 
1948
        # Restrict resolution to 1ms
 
1949
        self._timestamp = round(timestamp, 3)
 
1950
 
 
1951
        if timezone is None:
 
1952
            self._timezone = osutils.local_time_offset()
 
1953
        else:
 
1954
            self._timezone = int(timezone)
 
1955
 
 
1956
        self._generate_revision_if_needed()
 
1957
 
 
1958
    def commit(self, message):
 
1959
        """Make the actual commit.
 
1960
 
 
1961
        :return: The revision id of the recorded revision.
 
1962
        """
 
1963
        rev = _mod_revision.Revision(
 
1964
                       timestamp=self._timestamp,
 
1965
                       timezone=self._timezone,
 
1966
                       committer=self._committer,
 
1967
                       message=message,
 
1968
                       inventory_sha1=self.inv_sha1,
 
1969
                       revision_id=self._new_revision_id,
 
1970
                       properties=self._revprops)
 
1971
        rev.parent_ids = self.parents
 
1972
        self.repository.add_revision(self._new_revision_id, rev, 
 
1973
            self.new_inventory, self._config)
 
1974
        return self._new_revision_id
 
1975
 
 
1976
    def revision_tree(self):
 
1977
        """Return the tree that was just committed.
 
1978
 
 
1979
        After calling commit() this can be called to get a RevisionTree
 
1980
        representing the newly committed tree. This is preferred to
 
1981
        calling Repository.revision_tree() because that may require
 
1982
        deserializing the inventory, while we already have a copy in
 
1983
        memory.
 
1984
        """
 
1985
        return RevisionTree(self.repository, self.new_inventory,
 
1986
                            self._new_revision_id)
 
1987
 
 
1988
    def finish_inventory(self):
 
1989
        """Tell the builder that the inventory is finished."""
 
1990
        if self.new_inventory.root is None:
 
1991
            symbol_versioning.warn('Root entry should be supplied to'
 
1992
                ' record_entry_contents, as of bzr 0.10.',
 
1993
                 DeprecationWarning, stacklevel=2)
 
1994
            self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
 
1995
        self.new_inventory.revision_id = self._new_revision_id
 
1996
        self.inv_sha1 = self.repository.add_inventory(
 
1997
            self._new_revision_id,
 
1998
            self.new_inventory,
 
1999
            self.parents
 
2000
            )
 
2001
 
 
2002
    def _gen_revision_id(self):
 
2003
        """Return new revision-id."""
 
2004
        return generate_ids.gen_revision_id(self._config.username(),
 
2005
                                            self._timestamp)
 
2006
 
 
2007
    def _generate_revision_if_needed(self):
 
2008
        """Create a revision id if None was supplied.
 
2009
        
 
2010
        If the repository can not support user-specified revision ids
 
2011
        they should override this function and raise CannotSetRevisionId
 
2012
        if _new_revision_id is not None.
 
2013
 
 
2014
        :raises: CannotSetRevisionId
 
2015
        """
 
2016
        if self._new_revision_id is None:
 
2017
            self._new_revision_id = self._gen_revision_id()
 
2018
 
 
2019
    def record_entry_contents(self, ie, parent_invs, path, tree):
 
2020
        """Record the content of ie from tree into the commit if needed.
 
2021
 
 
2022
        Side effect: sets ie.revision when unchanged
 
2023
 
 
2024
        :param ie: An inventory entry present in the commit.
 
2025
        :param parent_invs: The inventories of the parent revisions of the
 
2026
            commit.
 
2027
        :param path: The path the entry is at in the tree.
 
2028
        :param tree: The tree which contains this entry and should be used to 
 
2029
        obtain content.
 
2030
        """
 
2031
        if self.new_inventory.root is None and ie.parent_id is not None:
 
2032
            symbol_versioning.warn('Root entry should be supplied to'
 
2033
                ' record_entry_contents, as of bzr 0.10.',
 
2034
                 DeprecationWarning, stacklevel=2)
 
2035
            self.record_entry_contents(tree.inventory.root.copy(), parent_invs,
 
2036
                                       '', tree)
 
2037
        self.new_inventory.add(ie)
 
2038
 
 
2039
        # ie.revision is always None if the InventoryEntry is considered
 
2040
        # for committing. ie.snapshot will record the correct revision 
 
2041
        # which may be the sole parent if it is untouched.
 
2042
        if ie.revision is not None:
 
2043
            return
 
2044
 
 
2045
        # In this revision format, root entries have no knit or weave
 
2046
        if ie is self.new_inventory.root:
 
2047
            # When serializing out to disk and back in
 
2048
            # root.revision is always _new_revision_id
 
2049
            ie.revision = self._new_revision_id
 
2050
            return
 
2051
        previous_entries = ie.find_previous_heads(
 
2052
            parent_invs,
 
2053
            self.repository.weave_store,
 
2054
            self.repository.get_transaction())
 
2055
        # we are creating a new revision for ie in the history store
 
2056
        # and inventory.
 
2057
        ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
 
2058
 
 
2059
    def modified_directory(self, file_id, file_parents):
 
2060
        """Record the presence of a symbolic link.
 
2061
 
 
2062
        :param file_id: The file_id of the link to record.
 
2063
        :param file_parents: The per-file parent revision ids.
 
2064
        """
 
2065
        self._add_text_to_weave(file_id, [], file_parents.keys())
 
2066
 
 
2067
    def modified_reference(self, file_id, file_parents):
 
2068
        """Record the modification of a reference.
 
2069
 
 
2070
        :param file_id: The file_id of the link to record.
 
2071
        :param file_parents: The per-file parent revision ids.
 
2072
        """
 
2073
        self._add_text_to_weave(file_id, [], file_parents.keys())
 
2074
    
 
2075
    def modified_file_text(self, file_id, file_parents,
 
2076
                           get_content_byte_lines, text_sha1=None,
 
2077
                           text_size=None):
 
2078
        """Record the text of file file_id
 
2079
 
 
2080
        :param file_id: The file_id of the file to record the text of.
 
2081
        :param file_parents: The per-file parent revision ids.
 
2082
        :param get_content_byte_lines: A callable which will return the byte
 
2083
            lines for the file.
 
2084
        :param text_sha1: Optional SHA1 of the file contents.
 
2085
        :param text_size: Optional size of the file contents.
 
2086
        """
 
2087
        # mutter('storing text of file {%s} in revision {%s} into %r',
 
2088
        #        file_id, self._new_revision_id, self.repository.weave_store)
 
2089
        # special case to avoid diffing on renames or 
 
2090
        # reparenting
 
2091
        if (len(file_parents) == 1
 
2092
            and text_sha1 == file_parents.values()[0].text_sha1
 
2093
            and text_size == file_parents.values()[0].text_size):
 
2094
            previous_ie = file_parents.values()[0]
 
2095
            versionedfile = self.repository.weave_store.get_weave(file_id, 
 
2096
                self.repository.get_transaction())
 
2097
            versionedfile.clone_text(self._new_revision_id, 
 
2098
                previous_ie.revision, file_parents.keys())
 
2099
            return text_sha1, text_size
 
2100
        else:
 
2101
            new_lines = get_content_byte_lines()
 
2102
            # TODO: Rather than invoking sha_strings here, _add_text_to_weave
 
2103
            # should return the SHA1 and size
 
2104
            self._add_text_to_weave(file_id, new_lines, file_parents.keys())
 
2105
            return osutils.sha_strings(new_lines), \
 
2106
                sum(map(len, new_lines))
 
2107
 
 
2108
    def modified_link(self, file_id, file_parents, link_target):
 
2109
        """Record the presence of a symbolic link.
 
2110
 
 
2111
        :param file_id: The file_id of the link to record.
 
2112
        :param file_parents: The per-file parent revision ids.
 
2113
        :param link_target: Target location of this link.
 
2114
        """
 
2115
        self._add_text_to_weave(file_id, [], file_parents.keys())
 
2116
 
 
2117
    def _add_text_to_weave(self, file_id, new_lines, parents):
 
2118
        versionedfile = self.repository.weave_store.get_weave_or_empty(
 
2119
            file_id, self.repository.get_transaction())
 
2120
        versionedfile.add_lines(self._new_revision_id, parents, new_lines)
 
2121
        versionedfile.clear_cache()
 
2122
 
 
2123
 
 
2124
class _CommitBuilder(CommitBuilder):
 
2125
    """Temporary class so old CommitBuilders are detected properly
 
2126
    
 
2127
    Note: CommitBuilder works whether or not root entry is recorded.
 
2128
    """
 
2129
 
 
2130
    record_root_entry = True
 
2131
 
 
2132
 
 
2133
class RootCommitBuilder(CommitBuilder):
 
2134
    """This commitbuilder actually records the root id"""
 
2135
    
 
2136
    record_root_entry = True
 
2137
 
 
2138
    def record_entry_contents(self, ie, parent_invs, path, tree):
 
2139
        """Record the content of ie from tree into the commit if needed.
 
2140
 
 
2141
        Side effect: sets ie.revision when unchanged
 
2142
 
 
2143
        :param ie: An inventory entry present in the commit.
 
2144
        :param parent_invs: The inventories of the parent revisions of the
 
2145
            commit.
 
2146
        :param path: The path the entry is at in the tree.
 
2147
        :param tree: The tree which contains this entry and should be used to 
 
2148
        obtain content.
 
2149
        """
 
2150
        assert self.new_inventory.root is not None or ie.parent_id is None
 
2151
        self.new_inventory.add(ie)
 
2152
 
 
2153
        # ie.revision is always None if the InventoryEntry is considered
 
2154
        # for committing. ie.snapshot will record the correct revision 
 
2155
        # which may be the sole parent if it is untouched.
 
2156
        if ie.revision is not None:
 
2157
            return
 
2158
 
 
2159
        previous_entries = ie.find_previous_heads(
 
2160
            parent_invs,
 
2161
            self.repository.weave_store,
 
2162
            self.repository.get_transaction())
 
2163
        # we are creating a new revision for ie in the history store
 
2164
        # and inventory.
 
2165
        ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
 
2166
 
 
2167
 
 
2168
_unescape_map = {
 
2169
    'apos':"'",
 
2170
    'quot':'"',
 
2171
    'amp':'&',
 
2172
    'lt':'<',
 
2173
    'gt':'>'
 
2174
}
 
2175
 
 
2176
 
 
2177
def _unescaper(match, _map=_unescape_map):
 
2178
    code = match.group(1)
1820
2179
    try:
1821
 
        # skip the last revision in the list
1822
 
        iterator.next()
1823
 
        while True:
1824
 
            if (stop_index is not None and
1825
 
                len(partial_history_cache) > stop_index):
1826
 
                break
1827
 
            if partial_history_cache[-1] == stop_revision:
1828
 
                break
1829
 
            revision_id = iterator.next()
1830
 
            partial_history_cache.append(revision_id)
1831
 
    except StopIteration:
1832
 
        # No more history
1833
 
        return
1834
 
 
1835
 
 
1836
 
class _LazyListJoin(object):
1837
 
    """An iterable yielding the contents of many lists as one list.
1838
 
 
1839
 
    Each iterator made from this will reflect the current contents of the lists
1840
 
    at the time the iterator is made.
1841
 
    
1842
 
    This is used by Repository's _make_parents_provider implementation so that
1843
 
    it is safe to do::
1844
 
 
1845
 
      pp = repo._make_parents_provider()      # uses a list of fallback repos
1846
 
      pp.add_fallback_repository(other_repo)  # appends to that list
1847
 
      result = pp.get_parent_map(...)
1848
 
      # The result will include revs from other_repo
1849
 
    """
1850
 
 
1851
 
    def __init__(self, *list_parts):
1852
 
        self.list_parts = list_parts
1853
 
 
1854
 
    def __iter__(self):
1855
 
        full_list = []
1856
 
        for list_part in self.list_parts:
1857
 
            full_list.extend(list_part)
1858
 
        return iter(full_list)
1859
 
 
1860
 
    def __repr__(self):
1861
 
        return "%s.%s(%s)" % (self.__module__, self.__class__.__name__,
1862
 
                              self.list_parts)
 
2180
        return _map[code]
 
2181
    except KeyError:
 
2182
        if not code.startswith('#'):
 
2183
            raise
 
2184
        return unichr(int(code[1:])).encode('utf8')
 
2185
 
 
2186
 
 
2187
_unescape_re = None
 
2188
 
 
2189
 
 
2190
def _unescape_xml(data):
 
2191
    """Unescape predefined XML entities in a string of data."""
 
2192
    global _unescape_re
 
2193
    if _unescape_re is None:
 
2194
        _unescape_re = re.compile('\&([^;]*);')
 
2195
    return _unescape_re.sub(_unescaper, data)