/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Alexander Belchenko
  • Date: 2007-01-30 12:13:18 UTC
  • mto: This revision was merged to the branch mainline in revision 2259.
  • Revision ID: bialix@ukr.net-20070130121318-a03bj0mol21o1rup
setup.py: fix plain 'python setup.py install' for win98

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
from cStringIO import StringIO
 
18
 
 
19
from bzrlib.lazy_import import lazy_import
 
20
lazy_import(globals(), """
 
21
from binascii import hexlify
 
22
from copy import deepcopy
 
23
import re
 
24
import time
 
25
import unittest
 
26
 
 
27
from bzrlib import (
 
28
    bzrdir,
 
29
    check,
 
30
    delta,
 
31
    errors,
 
32
    generate_ids,
 
33
    gpg,
 
34
    graph,
 
35
    knit,
 
36
    lazy_regex,
 
37
    lockable_files,
 
38
    lockdir,
 
39
    osutils,
 
40
    registry,
 
41
    revision as _mod_revision,
 
42
    symbol_versioning,
 
43
    transactions,
 
44
    ui,
 
45
    weave,
 
46
    weavefile,
 
47
    xml5,
 
48
    xml6,
 
49
    )
 
50
from bzrlib.osutils import (
 
51
    rand_bytes,
 
52
    compact_date, 
 
53
    local_time_offset,
 
54
    )
 
55
from bzrlib.revisiontree import RevisionTree
 
56
from bzrlib.store.versioned import VersionedFileStore
 
57
from bzrlib.store.text import TextStore
 
58
from bzrlib.testament import Testament
 
59
""")
 
60
 
 
61
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
62
from bzrlib.inter import InterObject
 
63
from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID
 
64
from bzrlib.symbol_versioning import (
 
65
        deprecated_method,
 
66
        zero_nine,
 
67
        )
 
68
from bzrlib.trace import mutter, note, warning
 
69
 
 
70
 
 
71
# Old formats display a warning, but only once
 
72
_deprecation_warning_done = False
 
73
 
 
74
 
 
75
class Repository(object):
 
76
    """Repository holding history for one or more branches.
 
77
 
 
78
    The repository holds and retrieves historical information including
 
79
    revisions and file history.  It's normally accessed only by the Branch,
 
80
    which views a particular line of development through that history.
 
81
 
 
82
    The Repository builds on top of Stores and a Transport, which respectively 
 
83
    describe the disk data format and the way of accessing the (possibly 
 
84
    remote) disk.
 
85
    """
 
86
 
 
87
    _file_ids_altered_regex = lazy_regex.lazy_compile(
 
88
        r'file_id="(?P<file_id>[^"]+)"'
 
89
        r'.*revision="(?P<revision_id>[^"]+)"'
 
90
        )
 
91
 
 
92
    @needs_write_lock
 
93
    def add_inventory(self, revid, inv, parents):
 
94
        """Add the inventory inv to the repository as revid.
 
95
        
 
96
        :param parents: The revision ids of the parents that revid
 
97
                        is known to have and are in the repository already.
 
98
 
 
99
        returns the sha1 of the serialized inventory.
 
100
        """
 
101
        _mod_revision.check_not_reserved_id(revid)
 
102
        assert inv.revision_id is None or inv.revision_id == revid, \
 
103
            "Mismatch between inventory revision" \
 
104
            " id and insertion revid (%r, %r)" % (inv.revision_id, revid)
 
105
        assert inv.root is not None
 
106
        inv_text = self.serialise_inventory(inv)
 
107
        inv_sha1 = osutils.sha_string(inv_text)
 
108
        inv_vf = self.control_weaves.get_weave('inventory',
 
109
                                               self.get_transaction())
 
110
        self._inventory_add_lines(inv_vf, revid, parents, osutils.split_lines(inv_text))
 
111
        return inv_sha1
 
112
 
 
113
    def _inventory_add_lines(self, inv_vf, revid, parents, lines):
 
114
        final_parents = []
 
115
        for parent in parents:
 
116
            if parent in inv_vf:
 
117
                final_parents.append(parent)
 
118
 
 
119
        inv_vf.add_lines(revid, final_parents, lines)
 
120
 
 
121
    @needs_write_lock
 
122
    def add_revision(self, rev_id, rev, inv=None, config=None):
 
123
        """Add rev to the revision store as rev_id.
 
124
 
 
125
        :param rev_id: the revision id to use.
 
126
        :param rev: The revision object.
 
127
        :param inv: The inventory for the revision. if None, it will be looked
 
128
                    up in the inventory storer
 
129
        :param config: If None no digital signature will be created.
 
130
                       If supplied its signature_needed method will be used
 
131
                       to determine if a signature should be made.
 
132
        """
 
133
        _mod_revision.check_not_reserved_id(rev_id)
 
134
        if config is not None and config.signature_needed():
 
135
            if inv is None:
 
136
                inv = self.get_inventory(rev_id)
 
137
            plaintext = Testament(rev, inv).as_short_text()
 
138
            self.store_revision_signature(
 
139
                gpg.GPGStrategy(config), plaintext, rev_id)
 
140
        if not rev_id in self.get_inventory_weave():
 
141
            if inv is None:
 
142
                raise errors.WeaveRevisionNotPresent(rev_id,
 
143
                                                     self.get_inventory_weave())
 
144
            else:
 
145
                # yes, this is not suitable for adding with ghosts.
 
146
                self.add_inventory(rev_id, inv, rev.parent_ids)
 
147
        self._revision_store.add_revision(rev, self.get_transaction())
 
148
 
 
149
    @needs_read_lock
 
150
    def _all_possible_ids(self):
 
151
        """Return all the possible revisions that we could find."""
 
152
        return self.get_inventory_weave().versions()
 
153
 
 
154
    def all_revision_ids(self):
 
155
        """Returns a list of all the revision ids in the repository. 
 
156
 
 
157
        This is deprecated because code should generally work on the graph
 
158
        reachable from a particular revision, and ignore any other revisions
 
159
        that might be present.  There is no direct replacement method.
 
160
        """
 
161
        return self._all_revision_ids()
 
162
 
 
163
    @needs_read_lock
 
164
    def _all_revision_ids(self):
 
165
        """Returns a list of all the revision ids in the repository. 
 
166
 
 
167
        These are in as much topological order as the underlying store can 
 
168
        present: for weaves ghosts may lead to a lack of correctness until
 
169
        the reweave updates the parents list.
 
170
        """
 
171
        if self._revision_store.text_store.listable():
 
172
            return self._revision_store.all_revision_ids(self.get_transaction())
 
173
        result = self._all_possible_ids()
 
174
        return self._eliminate_revisions_not_present(result)
 
175
 
 
176
    def break_lock(self):
 
177
        """Break a lock if one is present from another instance.
 
178
 
 
179
        Uses the ui factory to ask for confirmation if the lock may be from
 
180
        an active process.
 
181
        """
 
182
        self.control_files.break_lock()
 
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
 
 
196
    @staticmethod
 
197
    def create(a_bzrdir):
 
198
        """Construct the current default format repository in a_bzrdir."""
 
199
        return RepositoryFormat.get_default_format().initialize(a_bzrdir)
 
200
 
 
201
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
 
202
        """instantiate a Repository.
 
203
 
 
204
        :param _format: The format of the repository on disk.
 
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.
 
210
        """
 
211
        super(Repository, self).__init__()
 
212
        self._format = _format
 
213
        # the following are part of the public API for Repository:
 
214
        self.bzrdir = a_bzrdir
 
215
        self.control_files = control_files
 
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()
 
227
        self._serializer = xml5.serializer_v5
 
228
 
 
229
    def __repr__(self):
 
230
        return '%s(%r)' % (self.__class__.__name__, 
 
231
                           self.bzrdir.transport.base)
 
232
 
 
233
    def is_locked(self):
 
234
        return self.control_files.is_locked()
 
235
 
 
236
    def lock_write(self):
 
237
        self.control_files.lock_write()
 
238
 
 
239
    def lock_read(self):
 
240
        self.control_files.lock_read()
 
241
 
 
242
    def get_physical_lock_status(self):
 
243
        return self.control_files.get_physical_lock_status()
 
244
 
 
245
    @needs_read_lock
 
246
    def missing_revision_ids(self, other, revision_id=None):
 
247
        """Return the revision ids that other has that this does not.
 
248
        
 
249
        These are returned in topological order.
 
250
 
 
251
        revision_id: only return revision ids included by revision_id.
 
252
        """
 
253
        return InterRepository.get(other, self).missing_revision_ids(revision_id)
 
254
 
 
255
    @staticmethod
 
256
    def open(base):
 
257
        """Open the repository rooted at base.
 
258
 
 
259
        For instance, if the repository is at URL/.bzr/repository,
 
260
        Repository.open(URL) -> a Repository instance.
 
261
        """
 
262
        control = bzrdir.BzrDir.open(base)
 
263
        return control.open_repository()
 
264
 
 
265
    def copy_content_into(self, destination, revision_id=None, basis=None):
 
266
        """Make a complete copy of the content in self into destination.
 
267
        
 
268
        This is a destructive operation! Do not use it on existing 
 
269
        repositories.
 
270
        """
 
271
        return InterRepository.get(self, destination).copy_content(revision_id, basis)
 
272
 
 
273
    def fetch(self, source, revision_id=None, pb=None):
 
274
        """Fetch the content required to construct revision_id from source.
 
275
 
 
276
        If revision_id is None all content is copied.
 
277
        """
 
278
        return InterRepository.get(source, self).fetch(revision_id=revision_id,
 
279
                                                       pb=pb)
 
280
 
 
281
    def get_commit_builder(self, branch, parents, config, timestamp=None, 
 
282
                           timezone=None, committer=None, revprops=None, 
 
283
                           revision_id=None):
 
284
        """Obtain a CommitBuilder for this repository.
 
285
        
 
286
        :param branch: Branch to commit to.
 
287
        :param parents: Revision ids of the parents of the new revision.
 
288
        :param config: Configuration to use.
 
289
        :param timestamp: Optional timestamp recorded for commit.
 
290
        :param timezone: Optional timezone for timestamp.
 
291
        :param committer: Optional committer to set for commit.
 
292
        :param revprops: Optional dictionary of revision properties.
 
293
        :param revision_id: Optional revision id.
 
294
        """
 
295
        return _CommitBuilder(self, parents, config, timestamp, timezone,
 
296
                              committer, revprops, revision_id)
 
297
 
 
298
    def unlock(self):
 
299
        self.control_files.unlock()
 
300
 
 
301
    @needs_read_lock
 
302
    def clone(self, a_bzrdir, revision_id=None, basis=None):
 
303
        """Clone this repository into a_bzrdir using the current format.
 
304
 
 
305
        Currently no check is made that the format of this repository and
 
306
        the bzrdir format are compatible. FIXME RBC 20060201.
 
307
        """
 
308
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
309
            # use target default format.
 
310
            result = a_bzrdir.create_repository()
 
311
        # FIXME RBC 20060209 split out the repository type to avoid this check ?
 
312
        elif isinstance(a_bzrdir._format,
 
313
                      (bzrdir.BzrDirFormat4,
 
314
                       bzrdir.BzrDirFormat5,
 
315
                       bzrdir.BzrDirFormat6)):
 
316
            result = a_bzrdir.open_repository()
 
317
        else:
 
318
            result = self._format.initialize(a_bzrdir, shared=self.is_shared())
 
319
        self.copy_content_into(result, revision_id, basis)
 
320
        return result
 
321
 
 
322
    @needs_read_lock
 
323
    def has_revision(self, revision_id):
 
324
        """True if this repository has a copy of the revision."""
 
325
        return self._revision_store.has_revision_id(revision_id,
 
326
                                                    self.get_transaction())
 
327
 
 
328
    @needs_read_lock
 
329
    def get_revision_reconcile(self, revision_id):
 
330
        """'reconcile' helper routine that allows access to a revision always.
 
331
        
 
332
        This variant of get_revision does not cross check the weave graph
 
333
        against the revision one as get_revision does: but it should only
 
334
        be used by reconcile, or reconcile-alike commands that are correcting
 
335
        or testing the revision graph.
 
336
        """
 
337
        if not revision_id or not isinstance(revision_id, basestring):
 
338
            raise errors.InvalidRevisionId(revision_id=revision_id,
 
339
                                           branch=self)
 
340
        return self._revision_store.get_revisions([revision_id],
 
341
                                                  self.get_transaction())[0]
 
342
    @needs_read_lock
 
343
    def get_revisions(self, revision_ids):
 
344
        return self._revision_store.get_revisions(revision_ids,
 
345
                                                  self.get_transaction())
 
346
 
 
347
    @needs_read_lock
 
348
    def get_revision_xml(self, revision_id):
 
349
        rev = self.get_revision(revision_id) 
 
350
        rev_tmp = StringIO()
 
351
        # the current serializer..
 
352
        self._revision_store._serializer.write_revision(rev, rev_tmp)
 
353
        rev_tmp.seek(0)
 
354
        return rev_tmp.getvalue()
 
355
 
 
356
    @needs_read_lock
 
357
    def get_revision(self, revision_id):
 
358
        """Return the Revision object for a named revision"""
 
359
        r = self.get_revision_reconcile(revision_id)
 
360
        # weave corruption can lead to absent revision markers that should be
 
361
        # present.
 
362
        # the following test is reasonably cheap (it needs a single weave read)
 
363
        # and the weave is cached in read transactions. In write transactions
 
364
        # it is not cached but typically we only read a small number of
 
365
        # revisions. For knits when they are introduced we will probably want
 
366
        # to ensure that caching write transactions are in use.
 
367
        inv = self.get_inventory_weave()
 
368
        self._check_revision_parents(r, inv)
 
369
        return r
 
370
 
 
371
    @needs_read_lock
 
372
    def get_deltas_for_revisions(self, revisions):
 
373
        """Produce a generator of revision deltas.
 
374
        
 
375
        Note that the input is a sequence of REVISIONS, not revision_ids.
 
376
        Trees will be held in memory until the generator exits.
 
377
        Each delta is relative to the revision's lefthand predecessor.
 
378
        """
 
379
        required_trees = set()
 
380
        for revision in revisions:
 
381
            required_trees.add(revision.revision_id)
 
382
            required_trees.update(revision.parent_ids[:1])
 
383
        trees = dict((t.get_revision_id(), t) for 
 
384
                     t in self.revision_trees(required_trees))
 
385
        for revision in revisions:
 
386
            if not revision.parent_ids:
 
387
                old_tree = self.revision_tree(None)
 
388
            else:
 
389
                old_tree = trees[revision.parent_ids[0]]
 
390
            yield trees[revision.revision_id].changes_from(old_tree)
 
391
 
 
392
    @needs_read_lock
 
393
    def get_revision_delta(self, revision_id):
 
394
        """Return the delta for one revision.
 
395
 
 
396
        The delta is relative to the left-hand predecessor of the
 
397
        revision.
 
398
        """
 
399
        r = self.get_revision(revision_id)
 
400
        return list(self.get_deltas_for_revisions([r]))[0]
 
401
 
 
402
    def _check_revision_parents(self, revision, inventory):
 
403
        """Private to Repository and Fetch.
 
404
        
 
405
        This checks the parentage of revision in an inventory weave for 
 
406
        consistency and is only applicable to inventory-weave-for-ancestry
 
407
        using repository formats & fetchers.
 
408
        """
 
409
        weave_parents = inventory.get_parents(revision.revision_id)
 
410
        weave_names = inventory.versions()
 
411
        for parent_id in revision.parent_ids:
 
412
            if parent_id in weave_names:
 
413
                # this parent must not be a ghost.
 
414
                if not parent_id in weave_parents:
 
415
                    # but it is a ghost
 
416
                    raise errors.CorruptRepository(self)
 
417
 
 
418
    @needs_write_lock
 
419
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
420
        signature = gpg_strategy.sign(plaintext)
 
421
        self._revision_store.add_revision_signature_text(revision_id,
 
422
                                                         signature,
 
423
                                                         self.get_transaction())
 
424
 
 
425
    def fileids_altered_by_revision_ids(self, revision_ids):
 
426
        """Find the file ids and versions affected by revisions.
 
427
 
 
428
        :param revisions: an iterable containing revision ids.
 
429
        :return: a dictionary mapping altered file-ids to an iterable of
 
430
        revision_ids. Each altered file-ids has the exact revision_ids that
 
431
        altered it listed explicitly.
 
432
        """
 
433
        assert self._serializer.support_altered_by_hack, \
 
434
            ("fileids_altered_by_revision_ids only supported for branches " 
 
435
             "which store inventory as unnested xml, not on %r" % self)
 
436
        selected_revision_ids = set(revision_ids)
 
437
        w = self.get_inventory_weave()
 
438
        result = {}
 
439
 
 
440
        # this code needs to read every new line in every inventory for the
 
441
        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
 
442
        # not present in one of those inventories is unnecessary but not 
 
443
        # harmful because we are filtering by the revision id marker in the
 
444
        # inventory lines : we only select file ids altered in one of those  
 
445
        # revisions. We don't need to see all lines in the inventory because
 
446
        # only those added in an inventory in rev X can contain a revision=X
 
447
        # line.
 
448
        unescape_revid_cache = {}
 
449
        unescape_fileid_cache = {}
 
450
 
 
451
        # jam 20061218 In a big fetch, this handles hundreds of thousands
 
452
        # of lines, so it has had a lot of inlining and optimizing done.
 
453
        # Sorry that it is a little bit messy.
 
454
        # Move several functions to be local variables, since this is a long
 
455
        # running loop.
 
456
        search = self._file_ids_altered_regex.search
 
457
        unescape = _unescape_xml
 
458
        setdefault = result.setdefault
 
459
        pb = ui.ui_factory.nested_progress_bar()
 
460
        try:
 
461
            for line in w.iter_lines_added_or_present_in_versions(
 
462
                                        selected_revision_ids, pb=pb):
 
463
                match = search(line)
 
464
                if match is None:
 
465
                    continue
 
466
                # One call to match.group() returning multiple items is quite a
 
467
                # bit faster than 2 calls to match.group() each returning 1
 
468
                file_id, revision_id = match.group('file_id', 'revision_id')
 
469
 
 
470
                # Inlining the cache lookups helps a lot when you make 170,000
 
471
                # lines and 350k ids, versus 8.4 unique ids.
 
472
                # Using a cache helps in 2 ways:
 
473
                #   1) Avoids unnecessary decoding calls
 
474
                #   2) Re-uses cached strings, which helps in future set and
 
475
                #      equality checks.
 
476
                # (2) is enough that removing encoding entirely along with
 
477
                # the cache (so we are using plain strings) results in no
 
478
                # performance improvement.
 
479
                try:
 
480
                    revision_id = unescape_revid_cache[revision_id]
 
481
                except KeyError:
 
482
                    unescaped = unescape(revision_id)
 
483
                    unescape_revid_cache[revision_id] = unescaped
 
484
                    revision_id = unescaped
 
485
 
 
486
                if revision_id in selected_revision_ids:
 
487
                    try:
 
488
                        file_id = unescape_fileid_cache[file_id]
 
489
                    except KeyError:
 
490
                        unescaped = unescape(file_id)
 
491
                        unescape_fileid_cache[file_id] = unescaped
 
492
                        file_id = unescaped
 
493
                    setdefault(file_id, set()).add(revision_id)
 
494
        finally:
 
495
            pb.finished()
 
496
        return result
 
497
 
 
498
    @needs_read_lock
 
499
    def get_inventory_weave(self):
 
500
        return self.control_weaves.get_weave('inventory',
 
501
            self.get_transaction())
 
502
 
 
503
    @needs_read_lock
 
504
    def get_inventory(self, revision_id):
 
505
        """Get Inventory object by hash."""
 
506
        return self.deserialise_inventory(
 
507
            revision_id, self.get_inventory_xml(revision_id))
 
508
 
 
509
    def deserialise_inventory(self, revision_id, xml):
 
510
        """Transform the xml into an inventory object. 
 
511
 
 
512
        :param revision_id: The expected revision id of the inventory.
 
513
        :param xml: A serialised inventory.
 
514
        """
 
515
        result = self._serializer.read_inventory_from_string(xml)
 
516
        result.root.revision = revision_id
 
517
        return result
 
518
 
 
519
    def serialise_inventory(self, inv):
 
520
        return self._serializer.write_inventory_to_string(inv)
 
521
 
 
522
    @needs_read_lock
 
523
    def get_inventory_xml(self, revision_id):
 
524
        """Get inventory XML as a file object."""
 
525
        try:
 
526
            assert isinstance(revision_id, basestring), type(revision_id)
 
527
            iw = self.get_inventory_weave()
 
528
            return iw.get_text(revision_id)
 
529
        except IndexError:
 
530
            raise errors.HistoryMissing(self, 'inventory', revision_id)
 
531
 
 
532
    @needs_read_lock
 
533
    def get_inventory_sha1(self, revision_id):
 
534
        """Return the sha1 hash of the inventory entry
 
535
        """
 
536
        return self.get_revision(revision_id).inventory_sha1
 
537
 
 
538
    @needs_read_lock
 
539
    def get_revision_graph(self, revision_id=None):
 
540
        """Return a dictionary containing the revision graph.
 
541
        
 
542
        :param revision_id: The revision_id to get a graph from. If None, then
 
543
        the entire revision graph is returned. This is a deprecated mode of
 
544
        operation and will be removed in the future.
 
545
        :return: a dictionary of revision_id->revision_parents_list.
 
546
        """
 
547
        # special case NULL_REVISION
 
548
        if revision_id == _mod_revision.NULL_REVISION:
 
549
            return {}
 
550
        a_weave = self.get_inventory_weave()
 
551
        all_revisions = self._eliminate_revisions_not_present(
 
552
                                a_weave.versions())
 
553
        entire_graph = dict([(node, a_weave.get_parents(node)) for 
 
554
                             node in all_revisions])
 
555
        if revision_id is None:
 
556
            return entire_graph
 
557
        elif revision_id not in entire_graph:
 
558
            raise errors.NoSuchRevision(self, revision_id)
 
559
        else:
 
560
            # add what can be reached from revision_id
 
561
            result = {}
 
562
            pending = set([revision_id])
 
563
            while len(pending) > 0:
 
564
                node = pending.pop()
 
565
                result[node] = entire_graph[node]
 
566
                for revision_id in result[node]:
 
567
                    if revision_id not in result:
 
568
                        pending.add(revision_id)
 
569
            return result
 
570
 
 
571
    @needs_read_lock
 
572
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
573
        """Return a graph of the revisions with ghosts marked as applicable.
 
574
 
 
575
        :param revision_ids: an iterable of revisions to graph or None for all.
 
576
        :return: a Graph object with the graph reachable from revision_ids.
 
577
        """
 
578
        result = graph.Graph()
 
579
        if not revision_ids:
 
580
            pending = set(self.all_revision_ids())
 
581
            required = set([])
 
582
        else:
 
583
            pending = set(revision_ids)
 
584
            # special case NULL_REVISION
 
585
            if _mod_revision.NULL_REVISION in pending:
 
586
                pending.remove(_mod_revision.NULL_REVISION)
 
587
            required = set(pending)
 
588
        done = set([])
 
589
        while len(pending):
 
590
            revision_id = pending.pop()
 
591
            try:
 
592
                rev = self.get_revision(revision_id)
 
593
            except errors.NoSuchRevision:
 
594
                if revision_id in required:
 
595
                    raise
 
596
                # a ghost
 
597
                result.add_ghost(revision_id)
 
598
                continue
 
599
            for parent_id in rev.parent_ids:
 
600
                # is this queued or done ?
 
601
                if (parent_id not in pending and
 
602
                    parent_id not in done):
 
603
                    # no, queue it.
 
604
                    pending.add(parent_id)
 
605
            result.add_node(revision_id, rev.parent_ids)
 
606
            done.add(revision_id)
 
607
        return result
 
608
 
 
609
    @needs_read_lock
 
610
    def get_revision_inventory(self, revision_id):
 
611
        """Return inventory of a past revision."""
 
612
        # TODO: Unify this with get_inventory()
 
613
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
614
        # must be the same as its revision, so this is trivial.
 
615
        if revision_id is None:
 
616
            # This does not make sense: if there is no revision,
 
617
            # then it is the current tree inventory surely ?!
 
618
            # and thus get_root_id() is something that looks at the last
 
619
            # commit on the branch, and the get_root_id is an inventory check.
 
620
            raise NotImplementedError
 
621
            # return Inventory(self.get_root_id())
 
622
        else:
 
623
            return self.get_inventory(revision_id)
 
624
 
 
625
    @needs_read_lock
 
626
    def is_shared(self):
 
627
        """Return True if this repository is flagged as a shared repository."""
 
628
        raise NotImplementedError(self.is_shared)
 
629
 
 
630
    @needs_write_lock
 
631
    def reconcile(self, other=None, thorough=False):
 
632
        """Reconcile this repository."""
 
633
        from bzrlib.reconcile import RepoReconciler
 
634
        reconciler = RepoReconciler(self, thorough=thorough)
 
635
        reconciler.reconcile()
 
636
        return reconciler
 
637
    
 
638
    @needs_read_lock
 
639
    def revision_tree(self, revision_id):
 
640
        """Return Tree for a revision on this branch.
 
641
 
 
642
        `revision_id` may be None for the empty tree revision.
 
643
        """
 
644
        # TODO: refactor this to use an existing revision object
 
645
        # so we don't need to read it in twice.
 
646
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
 
647
            return RevisionTree(self, Inventory(root_id=None), 
 
648
                                _mod_revision.NULL_REVISION)
 
649
        else:
 
650
            inv = self.get_revision_inventory(revision_id)
 
651
            return RevisionTree(self, inv, revision_id)
 
652
 
 
653
    @needs_read_lock
 
654
    def revision_trees(self, revision_ids):
 
655
        """Return Tree for a revision on this branch.
 
656
 
 
657
        `revision_id` may not be None or 'null:'"""
 
658
        assert None not in revision_ids
 
659
        assert _mod_revision.NULL_REVISION not in revision_ids
 
660
        texts = self.get_inventory_weave().get_texts(revision_ids)
 
661
        for text, revision_id in zip(texts, revision_ids):
 
662
            inv = self.deserialise_inventory(revision_id, text)
 
663
            yield RevisionTree(self, inv, revision_id)
 
664
 
 
665
    @needs_read_lock
 
666
    def get_ancestry(self, revision_id):
 
667
        """Return a list of revision-ids integrated by a revision.
 
668
 
 
669
        The first element of the list is always None, indicating the origin 
 
670
        revision.  This might change when we have history horizons, or 
 
671
        perhaps we should have a new API.
 
672
        
 
673
        This is topologically sorted.
 
674
        """
 
675
        if revision_id is None:
 
676
            return [None]
 
677
        if not self.has_revision(revision_id):
 
678
            raise errors.NoSuchRevision(self, revision_id)
 
679
        w = self.get_inventory_weave()
 
680
        candidates = w.get_ancestry(revision_id)
 
681
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
 
682
 
 
683
    @needs_read_lock
 
684
    def print_file(self, file, revision_id):
 
685
        """Print `file` to stdout.
 
686
        
 
687
        FIXME RBC 20060125 as John Meinel points out this is a bad api
 
688
        - it writes to stdout, it assumes that that is valid etc. Fix
 
689
        by creating a new more flexible convenience function.
 
690
        """
 
691
        tree = self.revision_tree(revision_id)
 
692
        # use inventory as it was in that revision
 
693
        file_id = tree.inventory.path2id(file)
 
694
        if not file_id:
 
695
            # TODO: jam 20060427 Write a test for this code path
 
696
            #       it had a bug in it, and was raising the wrong
 
697
            #       exception.
 
698
            raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
 
699
        tree.print_file(file_id)
 
700
 
 
701
    def get_transaction(self):
 
702
        return self.control_files.get_transaction()
 
703
 
 
704
    def revision_parents(self, revid):
 
705
        return self.get_inventory_weave().parent_names(revid)
 
706
 
 
707
    @needs_write_lock
 
708
    def set_make_working_trees(self, new_value):
 
709
        """Set the policy flag for making working trees when creating branches.
 
710
 
 
711
        This only applies to branches that use this repository.
 
712
 
 
713
        The default is 'True'.
 
714
        :param new_value: True to restore the default, False to disable making
 
715
                          working trees.
 
716
        """
 
717
        raise NotImplementedError(self.set_make_working_trees)
 
718
    
 
719
    def make_working_trees(self):
 
720
        """Returns the policy for making working trees on new branches."""
 
721
        raise NotImplementedError(self.make_working_trees)
 
722
 
 
723
    @needs_write_lock
 
724
    def sign_revision(self, revision_id, gpg_strategy):
 
725
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
 
726
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
 
727
 
 
728
    @needs_read_lock
 
729
    def has_signature_for_revision_id(self, revision_id):
 
730
        """Query for a revision signature for revision_id in the repository."""
 
731
        return self._revision_store.has_signature(revision_id,
 
732
                                                  self.get_transaction())
 
733
 
 
734
    @needs_read_lock
 
735
    def get_signature_text(self, revision_id):
 
736
        """Return the text for a signature."""
 
737
        return self._revision_store.get_signature_text(revision_id,
 
738
                                                       self.get_transaction())
 
739
 
 
740
    @needs_read_lock
 
741
    def check(self, revision_ids):
 
742
        """Check consistency of all history of given revision_ids.
 
743
 
 
744
        Different repository implementations should override _check().
 
745
 
 
746
        :param revision_ids: A non-empty list of revision_ids whose ancestry
 
747
             will be checked.  Typically the last revision_id of a branch.
 
748
        """
 
749
        if not revision_ids:
 
750
            raise ValueError("revision_ids must be non-empty in %s.check" 
 
751
                    % (self,))
 
752
        return self._check(revision_ids)
 
753
 
 
754
    def _check(self, revision_ids):
 
755
        result = check.Check(self)
 
756
        result.check()
 
757
        return result
 
758
 
 
759
    def _warn_if_deprecated(self):
 
760
        global _deprecation_warning_done
 
761
        if _deprecation_warning_done:
 
762
            return
 
763
        _deprecation_warning_done = True
 
764
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
 
765
                % (self._format, self.bzrdir.transport.base))
 
766
 
 
767
    def supports_rich_root(self):
 
768
        return self._format.rich_root_data
 
769
 
 
770
    def _check_ascii_revisionid(self, revision_id, method):
 
771
        """Private helper for ascii-only repositories."""
 
772
        # weave repositories refuse to store revisionids that are non-ascii.
 
773
        if revision_id is not None:
 
774
            # weaves require ascii revision ids.
 
775
            if isinstance(revision_id, unicode):
 
776
                try:
 
777
                    revision_id.encode('ascii')
 
778
                except UnicodeEncodeError:
 
779
                    raise errors.NonAsciiRevisionId(method, self)
 
780
 
 
781
 
 
782
class AllInOneRepository(Repository):
 
783
    """Legacy support - the repository behaviour for all-in-one branches."""
 
784
 
 
785
    def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
 
786
        # we reuse one control files instance.
 
787
        dir_mode = a_bzrdir._control_files._dir_mode
 
788
        file_mode = a_bzrdir._control_files._file_mode
 
789
 
 
790
        def get_store(name, compressed=True, prefixed=False):
 
791
            # FIXME: This approach of assuming stores are all entirely compressed
 
792
            # or entirely uncompressed is tidy, but breaks upgrade from 
 
793
            # some existing branches where there's a mixture; we probably 
 
794
            # still want the option to look for both.
 
795
            relpath = a_bzrdir._control_files._escape(name)
 
796
            store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
 
797
                              prefixed=prefixed, compressed=compressed,
 
798
                              dir_mode=dir_mode,
 
799
                              file_mode=file_mode)
 
800
            #if self._transport.should_cache():
 
801
            #    cache_path = os.path.join(self.cache_root, name)
 
802
            #    os.mkdir(cache_path)
 
803
            #    store = bzrlib.store.CachedStore(store, cache_path)
 
804
            return store
 
805
 
 
806
        # not broken out yet because the controlweaves|inventory_store
 
807
        # and text_store | weave_store bits are still different.
 
808
        if isinstance(_format, RepositoryFormat4):
 
809
            # cannot remove these - there is still no consistent api 
 
810
            # which allows access to this old info.
 
811
            self.inventory_store = get_store('inventory-store')
 
812
            text_store = get_store('text-store')
 
813
        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
 
814
 
 
815
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
816
                           timezone=None, committer=None, revprops=None,
 
817
                           revision_id=None):
 
818
        self._check_ascii_revisionid(revision_id, self.get_commit_builder)
 
819
        return Repository.get_commit_builder(self, branch, parents, config,
 
820
            timestamp, timezone, committer, revprops, revision_id)
 
821
 
 
822
    @needs_read_lock
 
823
    def is_shared(self):
 
824
        """AllInOne repositories cannot be shared."""
 
825
        return False
 
826
 
 
827
    @needs_write_lock
 
828
    def set_make_working_trees(self, new_value):
 
829
        """Set the policy flag for making working trees when creating branches.
 
830
 
 
831
        This only applies to branches that use this repository.
 
832
 
 
833
        The default is 'True'.
 
834
        :param new_value: True to restore the default, False to disable making
 
835
                          working trees.
 
836
        """
 
837
        raise NotImplementedError(self.set_make_working_trees)
 
838
    
 
839
    def make_working_trees(self):
 
840
        """Returns the policy for making working trees on new branches."""
 
841
        return True
 
842
 
 
843
 
 
844
def install_revision(repository, rev, revision_tree):
 
845
    """Install all revision data into a repository."""
 
846
    present_parents = []
 
847
    parent_trees = {}
 
848
    for p_id in rev.parent_ids:
 
849
        if repository.has_revision(p_id):
 
850
            present_parents.append(p_id)
 
851
            parent_trees[p_id] = repository.revision_tree(p_id)
 
852
        else:
 
853
            parent_trees[p_id] = repository.revision_tree(None)
 
854
 
 
855
    inv = revision_tree.inventory
 
856
    entries = inv.iter_entries()
 
857
    # backwards compatability hack: skip the root id.
 
858
    if not repository.supports_rich_root():
 
859
        path, root = entries.next()
 
860
        if root.revision != rev.revision_id:
 
861
            raise errors.IncompatibleRevision(repr(repository))
 
862
    # Add the texts that are not already present
 
863
    for path, ie in entries:
 
864
        w = repository.weave_store.get_weave_or_empty(ie.file_id,
 
865
                repository.get_transaction())
 
866
        if ie.revision not in w:
 
867
            text_parents = []
 
868
            # FIXME: TODO: The following loop *may* be overlapping/duplicate
 
869
            # with InventoryEntry.find_previous_heads(). if it is, then there
 
870
            # is a latent bug here where the parents may have ancestors of each
 
871
            # other. RBC, AB
 
872
            for revision, tree in parent_trees.iteritems():
 
873
                if ie.file_id not in tree:
 
874
                    continue
 
875
                parent_id = tree.inventory[ie.file_id].revision
 
876
                if parent_id in text_parents:
 
877
                    continue
 
878
                text_parents.append(parent_id)
 
879
                    
 
880
            vfile = repository.weave_store.get_weave_or_empty(ie.file_id, 
 
881
                repository.get_transaction())
 
882
            lines = revision_tree.get_file(ie.file_id).readlines()
 
883
            vfile.add_lines(rev.revision_id, text_parents, lines)
 
884
    try:
 
885
        # install the inventory
 
886
        repository.add_inventory(rev.revision_id, inv, present_parents)
 
887
    except errors.RevisionAlreadyPresent:
 
888
        pass
 
889
    repository.add_revision(rev.revision_id, rev, inv)
 
890
 
 
891
 
 
892
class MetaDirRepository(Repository):
 
893
    """Repositories in the new meta-dir layout."""
 
894
 
 
895
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
 
896
        super(MetaDirRepository, self).__init__(_format,
 
897
                                                a_bzrdir,
 
898
                                                control_files,
 
899
                                                _revision_store,
 
900
                                                control_store,
 
901
                                                text_store)
 
902
        dir_mode = self.control_files._dir_mode
 
903
        file_mode = self.control_files._file_mode
 
904
 
 
905
    @needs_read_lock
 
906
    def is_shared(self):
 
907
        """Return True if this repository is flagged as a shared repository."""
 
908
        return self.control_files._transport.has('shared-storage')
 
909
 
 
910
    @needs_write_lock
 
911
    def set_make_working_trees(self, new_value):
 
912
        """Set the policy flag for making working trees when creating branches.
 
913
 
 
914
        This only applies to branches that use this repository.
 
915
 
 
916
        The default is 'True'.
 
917
        :param new_value: True to restore the default, False to disable making
 
918
                          working trees.
 
919
        """
 
920
        if new_value:
 
921
            try:
 
922
                self.control_files._transport.delete('no-working-trees')
 
923
            except errors.NoSuchFile:
 
924
                pass
 
925
        else:
 
926
            self.control_files.put_utf8('no-working-trees', '')
 
927
    
 
928
    def make_working_trees(self):
 
929
        """Returns the policy for making working trees on new branches."""
 
930
        return not self.control_files._transport.has('no-working-trees')
 
931
 
 
932
 
 
933
class WeaveMetaDirRepository(MetaDirRepository):
 
934
    """A subclass of MetaDirRepository to set weave specific policy."""
 
935
 
 
936
    def get_commit_builder(self, branch, parents, config, timestamp=None,
 
937
                           timezone=None, committer=None, revprops=None,
 
938
                           revision_id=None):
 
939
        self._check_ascii_revisionid(revision_id, self.get_commit_builder)
 
940
        return MetaDirRepository.get_commit_builder(self, branch, parents,
 
941
            config, timestamp, timezone, committer, revprops, revision_id)
 
942
 
 
943
 
 
944
class KnitRepository(MetaDirRepository):
 
945
    """Knit format repository."""
 
946
 
 
947
    def _warn_if_deprecated(self):
 
948
        # This class isn't deprecated
 
949
        pass
 
950
 
 
951
    def _inventory_add_lines(self, inv_vf, revid, parents, lines):
 
952
        inv_vf.add_lines_with_ghosts(revid, parents, lines)
 
953
 
 
954
    @needs_read_lock
 
955
    def _all_revision_ids(self):
 
956
        """See Repository.all_revision_ids()."""
 
957
        # Knits get the revision graph from the index of the revision knit, so
 
958
        # it's always possible even if they're on an unlistable transport.
 
959
        return self._revision_store.all_revision_ids(self.get_transaction())
 
960
 
 
961
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
962
        """Find file_id(s) which are involved in the changes between revisions.
 
963
 
 
964
        This determines the set of revisions which are involved, and then
 
965
        finds all file ids affected by those revisions.
 
966
        """
 
967
        vf = self._get_revision_vf()
 
968
        from_set = set(vf.get_ancestry(from_revid))
 
969
        to_set = set(vf.get_ancestry(to_revid))
 
970
        changed = to_set.difference(from_set)
 
971
        return self._fileid_involved_by_set(changed)
 
972
 
 
973
    def fileid_involved(self, last_revid=None):
 
974
        """Find all file_ids modified in the ancestry of last_revid.
 
975
 
 
976
        :param last_revid: If None, last_revision() will be used.
 
977
        """
 
978
        if not last_revid:
 
979
            changed = set(self.all_revision_ids())
 
980
        else:
 
981
            changed = set(self.get_ancestry(last_revid))
 
982
        if None in changed:
 
983
            changed.remove(None)
 
984
        return self._fileid_involved_by_set(changed)
 
985
 
 
986
    @needs_read_lock
 
987
    def get_ancestry(self, revision_id):
 
988
        """Return a list of revision-ids integrated by a revision.
 
989
        
 
990
        This is topologically sorted.
 
991
        """
 
992
        if revision_id is None:
 
993
            return [None]
 
994
        vf = self._get_revision_vf()
 
995
        try:
 
996
            return [None] + vf.get_ancestry(revision_id)
 
997
        except errors.RevisionNotPresent:
 
998
            raise errors.NoSuchRevision(self, revision_id)
 
999
 
 
1000
    @needs_read_lock
 
1001
    def get_revision(self, revision_id):
 
1002
        """Return the Revision object for a named revision"""
 
1003
        return self.get_revision_reconcile(revision_id)
 
1004
 
 
1005
    @needs_read_lock
 
1006
    def get_revision_graph(self, revision_id=None):
 
1007
        """Return a dictionary containing the revision graph.
 
1008
 
 
1009
        :param revision_id: The revision_id to get a graph from. If None, then
 
1010
        the entire revision graph is returned. This is a deprecated mode of
 
1011
        operation and will be removed in the future.
 
1012
        :return: a dictionary of revision_id->revision_parents_list.
 
1013
        """
 
1014
        # special case NULL_REVISION
 
1015
        if revision_id == _mod_revision.NULL_REVISION:
 
1016
            return {}
 
1017
        a_weave = self._get_revision_vf()
 
1018
        entire_graph = a_weave.get_graph()
 
1019
        if revision_id is None:
 
1020
            return a_weave.get_graph()
 
1021
        elif revision_id not in a_weave:
 
1022
            raise errors.NoSuchRevision(self, revision_id)
 
1023
        else:
 
1024
            # add what can be reached from revision_id
 
1025
            result = {}
 
1026
            pending = set([revision_id])
 
1027
            while len(pending) > 0:
 
1028
                node = pending.pop()
 
1029
                result[node] = a_weave.get_parents(node)
 
1030
                for revision_id in result[node]:
 
1031
                    if revision_id not in result:
 
1032
                        pending.add(revision_id)
 
1033
            return result
 
1034
 
 
1035
    @needs_read_lock
 
1036
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
1037
        """Return a graph of the revisions with ghosts marked as applicable.
 
1038
 
 
1039
        :param revision_ids: an iterable of revisions to graph or None for all.
 
1040
        :return: a Graph object with the graph reachable from revision_ids.
 
1041
        """
 
1042
        result = graph.Graph()
 
1043
        vf = self._get_revision_vf()
 
1044
        versions = set(vf.versions())
 
1045
        if not revision_ids:
 
1046
            pending = set(self.all_revision_ids())
 
1047
            required = set([])
 
1048
        else:
 
1049
            pending = set(revision_ids)
 
1050
            # special case NULL_REVISION
 
1051
            if _mod_revision.NULL_REVISION in pending:
 
1052
                pending.remove(_mod_revision.NULL_REVISION)
 
1053
            required = set(pending)
 
1054
        done = set([])
 
1055
        while len(pending):
 
1056
            revision_id = pending.pop()
 
1057
            if not revision_id in versions:
 
1058
                if revision_id in required:
 
1059
                    raise errors.NoSuchRevision(self, revision_id)
 
1060
                # a ghost
 
1061
                result.add_ghost(revision_id)
 
1062
                # mark it as done so we don't try for it again.
 
1063
                done.add(revision_id)
 
1064
                continue
 
1065
            parent_ids = vf.get_parents_with_ghosts(revision_id)
 
1066
            for parent_id in parent_ids:
 
1067
                # is this queued or done ?
 
1068
                if (parent_id not in pending and
 
1069
                    parent_id not in done):
 
1070
                    # no, queue it.
 
1071
                    pending.add(parent_id)
 
1072
            result.add_node(revision_id, parent_ids)
 
1073
            done.add(revision_id)
 
1074
        return result
 
1075
 
 
1076
    def _get_revision_vf(self):
 
1077
        """:return: a versioned file containing the revisions."""
 
1078
        vf = self._revision_store.get_revision_file(self.get_transaction())
 
1079
        return vf
 
1080
 
 
1081
    @needs_write_lock
 
1082
    def reconcile(self, other=None, thorough=False):
 
1083
        """Reconcile this repository."""
 
1084
        from bzrlib.reconcile import KnitReconciler
 
1085
        reconciler = KnitReconciler(self, thorough=thorough)
 
1086
        reconciler.reconcile()
 
1087
        return reconciler
 
1088
    
 
1089
    def revision_parents(self, revision_id):
 
1090
        return self._get_revision_vf().get_parents(revision_id)
 
1091
 
 
1092
 
 
1093
class KnitRepository2(KnitRepository):
 
1094
    """"""
 
1095
    def __init__(self, _format, a_bzrdir, control_files, _revision_store,
 
1096
                 control_store, text_store):
 
1097
        KnitRepository.__init__(self, _format, a_bzrdir, control_files,
 
1098
                              _revision_store, control_store, text_store)
 
1099
        self._serializer = xml6.serializer_v6
 
1100
 
 
1101
    def deserialise_inventory(self, revision_id, xml):
 
1102
        """Transform the xml into an inventory object. 
 
1103
 
 
1104
        :param revision_id: The expected revision id of the inventory.
 
1105
        :param xml: A serialised inventory.
 
1106
        """
 
1107
        result = self._serializer.read_inventory_from_string(xml)
 
1108
        assert result.root.revision is not None
 
1109
        return result
 
1110
 
 
1111
    def serialise_inventory(self, inv):
 
1112
        """Transform the inventory object into XML text.
 
1113
 
 
1114
        :param revision_id: The expected revision id of the inventory.
 
1115
        :param xml: A serialised inventory.
 
1116
        """
 
1117
        assert inv.revision_id is not None
 
1118
        assert inv.root.revision is not None
 
1119
        return KnitRepository.serialise_inventory(self, inv)
 
1120
 
 
1121
    def get_commit_builder(self, branch, parents, config, timestamp=None, 
 
1122
                           timezone=None, committer=None, revprops=None, 
 
1123
                           revision_id=None):
 
1124
        """Obtain a CommitBuilder for this repository.
 
1125
        
 
1126
        :param branch: Branch to commit to.
 
1127
        :param parents: Revision ids of the parents of the new revision.
 
1128
        :param config: Configuration to use.
 
1129
        :param timestamp: Optional timestamp recorded for commit.
 
1130
        :param timezone: Optional timezone for timestamp.
 
1131
        :param committer: Optional committer to set for commit.
 
1132
        :param revprops: Optional dictionary of revision properties.
 
1133
        :param revision_id: Optional revision id.
 
1134
        """
 
1135
        return RootCommitBuilder(self, parents, config, timestamp, timezone,
 
1136
                                 committer, revprops, revision_id)
 
1137
 
 
1138
 
 
1139
class RepositoryFormatRegistry(registry.Registry):
 
1140
    """Registry of RepositoryFormats.
 
1141
    """
 
1142
    
 
1143
 
 
1144
format_registry = RepositoryFormatRegistry()
 
1145
"""Registry of formats, indexed by their identifying format string."""
 
1146
 
 
1147
 
 
1148
class RepositoryFormat(object):
 
1149
    """A repository format.
 
1150
 
 
1151
    Formats provide three things:
 
1152
     * An initialization routine to construct repository data on disk.
 
1153
     * a format string which is used when the BzrDir supports versioned
 
1154
       children.
 
1155
     * an open routine which returns a Repository instance.
 
1156
 
 
1157
    Formats are placed in an dict by their format string for reference 
 
1158
    during opening. These should be subclasses of RepositoryFormat
 
1159
    for consistency.
 
1160
 
 
1161
    Once a format is deprecated, just deprecate the initialize and open
 
1162
    methods on the format class. Do not deprecate the object, as the 
 
1163
    object will be created every system load.
 
1164
 
 
1165
    Common instance attributes:
 
1166
    _matchingbzrdir - the bzrdir format that the repository format was
 
1167
    originally written to work with. This can be used if manually
 
1168
    constructing a bzrdir and repository, or more commonly for test suite
 
1169
    parameterisation.
 
1170
    """
 
1171
 
 
1172
    def __str__(self):
 
1173
        return "<%s>" % self.__class__.__name__
 
1174
 
 
1175
    @classmethod
 
1176
    def find_format(klass, a_bzrdir):
 
1177
        """Return the format for the repository object in a_bzrdir.
 
1178
        
 
1179
        This is used by bzr native formats that have a "format" file in
 
1180
        the repository.  Other methods may be used by different types of 
 
1181
        control directory.
 
1182
        """
 
1183
        try:
 
1184
            transport = a_bzrdir.get_repository_transport(None)
 
1185
            format_string = transport.get("format").read()
 
1186
            return format_registry.get(format_string)
 
1187
        except errors.NoSuchFile:
 
1188
            raise errors.NoRepositoryPresent(a_bzrdir)
 
1189
        except KeyError:
 
1190
            raise errors.UnknownFormatError(format=format_string)
 
1191
 
 
1192
    @classmethod
 
1193
    @deprecated_method(symbol_versioning.zero_fourteen)
 
1194
    def set_default_format(klass, format):
 
1195
        klass._set_default_format(format)
 
1196
 
 
1197
    @classmethod
 
1198
    def _set_default_format(klass, format):
 
1199
        """Set the default format for new Repository creation.
 
1200
 
 
1201
        The format must already be registered.
 
1202
        """
 
1203
        format_registry.default_key = format.get_format_string()
 
1204
 
 
1205
    @classmethod
 
1206
    def register_format(klass, format):
 
1207
        format_registry.register(format.get_format_string(), format)
 
1208
 
 
1209
    @classmethod
 
1210
    def unregister_format(klass, format):
 
1211
        format_registry.remove(format.get_format_string())
 
1212
    
 
1213
    @classmethod
 
1214
    def get_default_format(klass):
 
1215
        """Return the current default format."""
 
1216
        return format_registry.get(format_registry.default_key)
 
1217
 
 
1218
    def _get_control_store(self, repo_transport, control_files):
 
1219
        """Return the control store for this repository."""
 
1220
        raise NotImplementedError(self._get_control_store)
 
1221
 
 
1222
    def get_format_string(self):
 
1223
        """Return the ASCII format string that identifies this format.
 
1224
        
 
1225
        Note that in pre format ?? repositories the format string is 
 
1226
        not permitted nor written to disk.
 
1227
        """
 
1228
        raise NotImplementedError(self.get_format_string)
 
1229
 
 
1230
    def get_format_description(self):
 
1231
        """Return the short description for this format."""
 
1232
        raise NotImplementedError(self.get_format_description)
 
1233
 
 
1234
    def _get_revision_store(self, repo_transport, control_files):
 
1235
        """Return the revision store object for this a_bzrdir."""
 
1236
        raise NotImplementedError(self._get_revision_store)
 
1237
 
 
1238
    def _get_text_rev_store(self,
 
1239
                            transport,
 
1240
                            control_files,
 
1241
                            name,
 
1242
                            compressed=True,
 
1243
                            prefixed=False,
 
1244
                            serializer=None):
 
1245
        """Common logic for getting a revision store for a repository.
 
1246
        
 
1247
        see self._get_revision_store for the subclass-overridable method to 
 
1248
        get the store for a repository.
 
1249
        """
 
1250
        from bzrlib.store.revision.text import TextRevisionStore
 
1251
        dir_mode = control_files._dir_mode
 
1252
        file_mode = control_files._file_mode
 
1253
        text_store =TextStore(transport.clone(name),
 
1254
                              prefixed=prefixed,
 
1255
                              compressed=compressed,
 
1256
                              dir_mode=dir_mode,
 
1257
                              file_mode=file_mode)
 
1258
        _revision_store = TextRevisionStore(text_store, serializer)
 
1259
        return _revision_store
 
1260
 
 
1261
    def _get_versioned_file_store(self,
 
1262
                                  name,
 
1263
                                  transport,
 
1264
                                  control_files,
 
1265
                                  prefixed=True,
 
1266
                                  versionedfile_class=weave.WeaveFile,
 
1267
                                  versionedfile_kwargs={},
 
1268
                                  escaped=False):
 
1269
        weave_transport = control_files._transport.clone(name)
 
1270
        dir_mode = control_files._dir_mode
 
1271
        file_mode = control_files._file_mode
 
1272
        return VersionedFileStore(weave_transport, prefixed=prefixed,
 
1273
                                  dir_mode=dir_mode,
 
1274
                                  file_mode=file_mode,
 
1275
                                  versionedfile_class=versionedfile_class,
 
1276
                                  versionedfile_kwargs=versionedfile_kwargs,
 
1277
                                  escaped=escaped)
 
1278
 
 
1279
    def initialize(self, a_bzrdir, shared=False):
 
1280
        """Initialize a repository of this format in a_bzrdir.
 
1281
 
 
1282
        :param a_bzrdir: The bzrdir to put the new repository in it.
 
1283
        :param shared: The repository should be initialized as a sharable one.
 
1284
 
 
1285
        This may raise UninitializableFormat if shared repository are not
 
1286
        compatible the a_bzrdir.
 
1287
        """
 
1288
 
 
1289
    def is_supported(self):
 
1290
        """Is this format supported?
 
1291
 
 
1292
        Supported formats must be initializable and openable.
 
1293
        Unsupported formats may not support initialization or committing or 
 
1294
        some other features depending on the reason for not being supported.
 
1295
        """
 
1296
        return True
 
1297
 
 
1298
    def check_conversion_target(self, target_format):
 
1299
        raise NotImplementedError(self.check_conversion_target)
 
1300
 
 
1301
    def open(self, a_bzrdir, _found=False):
 
1302
        """Return an instance of this format for the bzrdir a_bzrdir.
 
1303
        
 
1304
        _found is a private parameter, do not use it.
 
1305
        """
 
1306
        raise NotImplementedError(self.open)
 
1307
 
 
1308
 
 
1309
class PreSplitOutRepositoryFormat(RepositoryFormat):
 
1310
    """Base class for the pre split out repository formats."""
 
1311
 
 
1312
    rich_root_data = False
 
1313
 
 
1314
    def initialize(self, a_bzrdir, shared=False, _internal=False):
 
1315
        """Create a weave repository.
 
1316
        
 
1317
        TODO: when creating split out bzr branch formats, move this to a common
 
1318
        base for Format5, Format6. or something like that.
 
1319
        """
 
1320
        if shared:
 
1321
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
 
1322
 
 
1323
        if not _internal:
 
1324
            # always initialized when the bzrdir is.
 
1325
            return self.open(a_bzrdir, _found=True)
 
1326
        
 
1327
        # Create an empty weave
 
1328
        sio = StringIO()
 
1329
        weavefile.write_weave_v5(weave.Weave(), sio)
 
1330
        empty_weave = sio.getvalue()
 
1331
 
 
1332
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
1333
        dirs = ['revision-store', 'weaves']
 
1334
        files = [('inventory.weave', StringIO(empty_weave)),
 
1335
                 ]
 
1336
        
 
1337
        # FIXME: RBC 20060125 don't peek under the covers
 
1338
        # NB: no need to escape relative paths that are url safe.
 
1339
        control_files = lockable_files.LockableFiles(a_bzrdir.transport,
 
1340
                                'branch-lock', lockable_files.TransportLock)
 
1341
        control_files.create_lock()
 
1342
        control_files.lock_write()
 
1343
        control_files._transport.mkdir_multi(dirs,
 
1344
                mode=control_files._dir_mode)
 
1345
        try:
 
1346
            for file, content in files:
 
1347
                control_files.put(file, content)
 
1348
        finally:
 
1349
            control_files.unlock()
 
1350
        return self.open(a_bzrdir, _found=True)
 
1351
 
 
1352
    def _get_control_store(self, repo_transport, control_files):
 
1353
        """Return the control store for this repository."""
 
1354
        return self._get_versioned_file_store('',
 
1355
                                              repo_transport,
 
1356
                                              control_files,
 
1357
                                              prefixed=False)
 
1358
 
 
1359
    def _get_text_store(self, transport, control_files):
 
1360
        """Get a store for file texts for this format."""
 
1361
        raise NotImplementedError(self._get_text_store)
 
1362
 
 
1363
    def open(self, a_bzrdir, _found=False):
 
1364
        """See RepositoryFormat.open()."""
 
1365
        if not _found:
 
1366
            # we are being called directly and must probe.
 
1367
            raise NotImplementedError
 
1368
 
 
1369
        repo_transport = a_bzrdir.get_repository_transport(None)
 
1370
        control_files = a_bzrdir._control_files
 
1371
        text_store = self._get_text_store(repo_transport, control_files)
 
1372
        control_store = self._get_control_store(repo_transport, control_files)
 
1373
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1374
        return AllInOneRepository(_format=self,
 
1375
                                  a_bzrdir=a_bzrdir,
 
1376
                                  _revision_store=_revision_store,
 
1377
                                  control_store=control_store,
 
1378
                                  text_store=text_store)
 
1379
 
 
1380
    def check_conversion_target(self, target_format):
 
1381
        pass
 
1382
 
 
1383
 
 
1384
class RepositoryFormat4(PreSplitOutRepositoryFormat):
 
1385
    """Bzr repository format 4.
 
1386
 
 
1387
    This repository format has:
 
1388
     - flat stores
 
1389
     - TextStores for texts, inventories,revisions.
 
1390
 
 
1391
    This format is deprecated: it indexes texts using a text id which is
 
1392
    removed in format 5; initialization and write support for this format
 
1393
    has been removed.
 
1394
    """
 
1395
 
 
1396
    def __init__(self):
 
1397
        super(RepositoryFormat4, self).__init__()
 
1398
        self._matchingbzrdir = bzrdir.BzrDirFormat4()
 
1399
 
 
1400
    def get_format_description(self):
 
1401
        """See RepositoryFormat.get_format_description()."""
 
1402
        return "Repository format 4"
 
1403
 
 
1404
    def initialize(self, url, shared=False, _internal=False):
 
1405
        """Format 4 branches cannot be created."""
 
1406
        raise errors.UninitializableFormat(self)
 
1407
 
 
1408
    def is_supported(self):
 
1409
        """Format 4 is not supported.
 
1410
 
 
1411
        It is not supported because the model changed from 4 to 5 and the
 
1412
        conversion logic is expensive - so doing it on the fly was not 
 
1413
        feasible.
 
1414
        """
 
1415
        return False
 
1416
 
 
1417
    def _get_control_store(self, repo_transport, control_files):
 
1418
        """Format 4 repositories have no formal control store at this point.
 
1419
        
 
1420
        This will cause any control-file-needing apis to fail - this is desired.
 
1421
        """
 
1422
        return None
 
1423
    
 
1424
    def _get_revision_store(self, repo_transport, control_files):
 
1425
        """See RepositoryFormat._get_revision_store()."""
 
1426
        from bzrlib.xml4 import serializer_v4
 
1427
        return self._get_text_rev_store(repo_transport,
 
1428
                                        control_files,
 
1429
                                        'revision-store',
 
1430
                                        serializer=serializer_v4)
 
1431
 
 
1432
    def _get_text_store(self, transport, control_files):
 
1433
        """See RepositoryFormat._get_text_store()."""
 
1434
 
 
1435
 
 
1436
class RepositoryFormat5(PreSplitOutRepositoryFormat):
 
1437
    """Bzr control format 5.
 
1438
 
 
1439
    This repository format has:
 
1440
     - weaves for file texts and inventory
 
1441
     - flat stores
 
1442
     - TextStores for revisions and signatures.
 
1443
    """
 
1444
 
 
1445
    def __init__(self):
 
1446
        super(RepositoryFormat5, self).__init__()
 
1447
        self._matchingbzrdir = bzrdir.BzrDirFormat5()
 
1448
 
 
1449
    def get_format_description(self):
 
1450
        """See RepositoryFormat.get_format_description()."""
 
1451
        return "Weave repository format 5"
 
1452
 
 
1453
    def _get_revision_store(self, repo_transport, control_files):
 
1454
        """See RepositoryFormat._get_revision_store()."""
 
1455
        """Return the revision store object for this a_bzrdir."""
 
1456
        return self._get_text_rev_store(repo_transport,
 
1457
                                        control_files,
 
1458
                                        'revision-store',
 
1459
                                        compressed=False)
 
1460
 
 
1461
    def _get_text_store(self, transport, control_files):
 
1462
        """See RepositoryFormat._get_text_store()."""
 
1463
        return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
 
1464
 
 
1465
 
 
1466
class RepositoryFormat6(PreSplitOutRepositoryFormat):
 
1467
    """Bzr control format 6.
 
1468
 
 
1469
    This repository format has:
 
1470
     - weaves for file texts and inventory
 
1471
     - hash subdirectory based stores.
 
1472
     - TextStores for revisions and signatures.
 
1473
    """
 
1474
 
 
1475
    def __init__(self):
 
1476
        super(RepositoryFormat6, self).__init__()
 
1477
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
 
1478
 
 
1479
    def get_format_description(self):
 
1480
        """See RepositoryFormat.get_format_description()."""
 
1481
        return "Weave repository format 6"
 
1482
 
 
1483
    def _get_revision_store(self, repo_transport, control_files):
 
1484
        """See RepositoryFormat._get_revision_store()."""
 
1485
        return self._get_text_rev_store(repo_transport,
 
1486
                                        control_files,
 
1487
                                        'revision-store',
 
1488
                                        compressed=False,
 
1489
                                        prefixed=True)
 
1490
 
 
1491
    def _get_text_store(self, transport, control_files):
 
1492
        """See RepositoryFormat._get_text_store()."""
 
1493
        return self._get_versioned_file_store('weaves', transport, control_files)
 
1494
 
 
1495
 
 
1496
class MetaDirRepositoryFormat(RepositoryFormat):
 
1497
    """Common base class for the new repositories using the metadir layout."""
 
1498
 
 
1499
    rich_root_data = False
 
1500
 
 
1501
    def __init__(self):
 
1502
        super(MetaDirRepositoryFormat, self).__init__()
 
1503
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1504
 
 
1505
    def _create_control_files(self, a_bzrdir):
 
1506
        """Create the required files and the initial control_files object."""
 
1507
        # FIXME: RBC 20060125 don't peek under the covers
 
1508
        # NB: no need to escape relative paths that are url safe.
 
1509
        repository_transport = a_bzrdir.get_repository_transport(self)
 
1510
        control_files = lockable_files.LockableFiles(repository_transport,
 
1511
                                'lock', lockdir.LockDir)
 
1512
        control_files.create_lock()
 
1513
        return control_files
 
1514
 
 
1515
    def _upload_blank_content(self, a_bzrdir, dirs, files, utf8_files, shared):
 
1516
        """Upload the initial blank content."""
 
1517
        control_files = self._create_control_files(a_bzrdir)
 
1518
        control_files.lock_write()
 
1519
        try:
 
1520
            control_files._transport.mkdir_multi(dirs,
 
1521
                    mode=control_files._dir_mode)
 
1522
            for file, content in files:
 
1523
                control_files.put(file, content)
 
1524
            for file, content in utf8_files:
 
1525
                control_files.put_utf8(file, content)
 
1526
            if shared == True:
 
1527
                control_files.put_utf8('shared-storage', '')
 
1528
        finally:
 
1529
            control_files.unlock()
 
1530
 
 
1531
 
 
1532
class RepositoryFormat7(MetaDirRepositoryFormat):
 
1533
    """Bzr repository 7.
 
1534
 
 
1535
    This repository format has:
 
1536
     - weaves for file texts and inventory
 
1537
     - hash subdirectory based stores.
 
1538
     - TextStores for revisions and signatures.
 
1539
     - a format marker of its own
 
1540
     - an optional 'shared-storage' flag
 
1541
     - an optional 'no-working-trees' flag
 
1542
    """
 
1543
 
 
1544
    def _get_control_store(self, repo_transport, control_files):
 
1545
        """Return the control store for this repository."""
 
1546
        return self._get_versioned_file_store('',
 
1547
                                              repo_transport,
 
1548
                                              control_files,
 
1549
                                              prefixed=False)
 
1550
 
 
1551
    def get_format_string(self):
 
1552
        """See RepositoryFormat.get_format_string()."""
 
1553
        return "Bazaar-NG Repository format 7"
 
1554
 
 
1555
    def get_format_description(self):
 
1556
        """See RepositoryFormat.get_format_description()."""
 
1557
        return "Weave repository format 7"
 
1558
 
 
1559
    def check_conversion_target(self, target_format):
 
1560
        pass
 
1561
 
 
1562
    def _get_revision_store(self, repo_transport, control_files):
 
1563
        """See RepositoryFormat._get_revision_store()."""
 
1564
        return self._get_text_rev_store(repo_transport,
 
1565
                                        control_files,
 
1566
                                        'revision-store',
 
1567
                                        compressed=False,
 
1568
                                        prefixed=True,
 
1569
                                        )
 
1570
 
 
1571
    def _get_text_store(self, transport, control_files):
 
1572
        """See RepositoryFormat._get_text_store()."""
 
1573
        return self._get_versioned_file_store('weaves',
 
1574
                                              transport,
 
1575
                                              control_files)
 
1576
 
 
1577
    def initialize(self, a_bzrdir, shared=False):
 
1578
        """Create a weave repository.
 
1579
 
 
1580
        :param shared: If true the repository will be initialized as a shared
 
1581
                       repository.
 
1582
        """
 
1583
        # Create an empty weave
 
1584
        sio = StringIO()
 
1585
        weavefile.write_weave_v5(weave.Weave(), sio)
 
1586
        empty_weave = sio.getvalue()
 
1587
 
 
1588
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
1589
        dirs = ['revision-store', 'weaves']
 
1590
        files = [('inventory.weave', StringIO(empty_weave)), 
 
1591
                 ]
 
1592
        utf8_files = [('format', self.get_format_string())]
 
1593
 
 
1594
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
1595
        return self.open(a_bzrdir=a_bzrdir, _found=True)
 
1596
 
 
1597
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
1598
        """See RepositoryFormat.open().
 
1599
        
 
1600
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
1601
                                    repository at a slightly different url
 
1602
                                    than normal. I.e. during 'upgrade'.
 
1603
        """
 
1604
        if not _found:
 
1605
            format = RepositoryFormat.find_format(a_bzrdir)
 
1606
            assert format.__class__ ==  self.__class__
 
1607
        if _override_transport is not None:
 
1608
            repo_transport = _override_transport
 
1609
        else:
 
1610
            repo_transport = a_bzrdir.get_repository_transport(None)
 
1611
        control_files = lockable_files.LockableFiles(repo_transport,
 
1612
                                'lock', lockdir.LockDir)
 
1613
        text_store = self._get_text_store(repo_transport, control_files)
 
1614
        control_store = self._get_control_store(repo_transport, control_files)
 
1615
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1616
        return WeaveMetaDirRepository(_format=self,
 
1617
            a_bzrdir=a_bzrdir,
 
1618
            control_files=control_files,
 
1619
            _revision_store=_revision_store,
 
1620
            control_store=control_store,
 
1621
            text_store=text_store)
 
1622
 
 
1623
 
 
1624
class RepositoryFormatKnit(MetaDirRepositoryFormat):
 
1625
    """Bzr repository knit format (generalized). 
 
1626
 
 
1627
    This repository format has:
 
1628
     - knits for file texts and inventory
 
1629
     - hash subdirectory based stores.
 
1630
     - knits for revisions and signatures
 
1631
     - TextStores for revisions and signatures.
 
1632
     - a format marker of its own
 
1633
     - an optional 'shared-storage' flag
 
1634
     - an optional 'no-working-trees' flag
 
1635
     - a LockDir lock
 
1636
    """
 
1637
 
 
1638
    def _get_control_store(self, repo_transport, control_files):
 
1639
        """Return the control store for this repository."""
 
1640
        return VersionedFileStore(
 
1641
            repo_transport,
 
1642
            prefixed=False,
 
1643
            file_mode=control_files._file_mode,
 
1644
            versionedfile_class=knit.KnitVersionedFile,
 
1645
            versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
 
1646
            )
 
1647
 
 
1648
    def _get_revision_store(self, repo_transport, control_files):
 
1649
        """See RepositoryFormat._get_revision_store()."""
 
1650
        from bzrlib.store.revision.knit import KnitRevisionStore
 
1651
        versioned_file_store = VersionedFileStore(
 
1652
            repo_transport,
 
1653
            file_mode=control_files._file_mode,
 
1654
            prefixed=False,
 
1655
            precious=True,
 
1656
            versionedfile_class=knit.KnitVersionedFile,
 
1657
            versionedfile_kwargs={'delta':False,
 
1658
                                  'factory':knit.KnitPlainFactory(),
 
1659
                                 },
 
1660
            escaped=True,
 
1661
            )
 
1662
        return KnitRevisionStore(versioned_file_store)
 
1663
 
 
1664
    def _get_text_store(self, transport, control_files):
 
1665
        """See RepositoryFormat._get_text_store()."""
 
1666
        return self._get_versioned_file_store('knits',
 
1667
                                  transport,
 
1668
                                  control_files,
 
1669
                                  versionedfile_class=knit.KnitVersionedFile,
 
1670
                                  versionedfile_kwargs={
 
1671
                                      'create_parent_dir':True,
 
1672
                                      'delay_create':True,
 
1673
                                      'dir_mode':control_files._dir_mode,
 
1674
                                  },
 
1675
                                  escaped=True)
 
1676
 
 
1677
    def initialize(self, a_bzrdir, shared=False):
 
1678
        """Create a knit format 1 repository.
 
1679
 
 
1680
        :param a_bzrdir: bzrdir to contain the new repository; must already
 
1681
            be initialized.
 
1682
        :param shared: If true the repository will be initialized as a shared
 
1683
                       repository.
 
1684
        """
 
1685
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
1686
        dirs = ['revision-store', 'knits']
 
1687
        files = []
 
1688
        utf8_files = [('format', self.get_format_string())]
 
1689
        
 
1690
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
1691
        repo_transport = a_bzrdir.get_repository_transport(None)
 
1692
        control_files = lockable_files.LockableFiles(repo_transport,
 
1693
                                'lock', lockdir.LockDir)
 
1694
        control_store = self._get_control_store(repo_transport, control_files)
 
1695
        transaction = transactions.WriteTransaction()
 
1696
        # trigger a write of the inventory store.
 
1697
        control_store.get_weave_or_empty('inventory', transaction)
 
1698
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1699
        # the revision id here is irrelevant: it will not be stored, and cannot
 
1700
        # already exist.
 
1701
        _revision_store.has_revision_id('A', transaction)
 
1702
        _revision_store.get_signature_file(transaction)
 
1703
        return self.open(a_bzrdir=a_bzrdir, _found=True)
 
1704
 
 
1705
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
1706
        """See RepositoryFormat.open().
 
1707
        
 
1708
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
1709
                                    repository at a slightly different url
 
1710
                                    than normal. I.e. during 'upgrade'.
 
1711
        """
 
1712
        if not _found:
 
1713
            format = RepositoryFormat.find_format(a_bzrdir)
 
1714
            assert format.__class__ ==  self.__class__
 
1715
        if _override_transport is not None:
 
1716
            repo_transport = _override_transport
 
1717
        else:
 
1718
            repo_transport = a_bzrdir.get_repository_transport(None)
 
1719
        control_files = lockable_files.LockableFiles(repo_transport,
 
1720
                                'lock', lockdir.LockDir)
 
1721
        text_store = self._get_text_store(repo_transport, control_files)
 
1722
        control_store = self._get_control_store(repo_transport, control_files)
 
1723
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1724
        return KnitRepository(_format=self,
 
1725
                              a_bzrdir=a_bzrdir,
 
1726
                              control_files=control_files,
 
1727
                              _revision_store=_revision_store,
 
1728
                              control_store=control_store,
 
1729
                              text_store=text_store)
 
1730
 
 
1731
 
 
1732
class RepositoryFormatKnit1(RepositoryFormatKnit):
 
1733
    """Bzr repository knit format 1.
 
1734
 
 
1735
    This repository format has:
 
1736
     - knits for file texts and inventory
 
1737
     - hash subdirectory based stores.
 
1738
     - knits for revisions and signatures
 
1739
     - TextStores for revisions and signatures.
 
1740
     - a format marker of its own
 
1741
     - an optional 'shared-storage' flag
 
1742
     - an optional 'no-working-trees' flag
 
1743
     - a LockDir lock
 
1744
 
 
1745
    This format was introduced in bzr 0.8.
 
1746
    """
 
1747
    def get_format_string(self):
 
1748
        """See RepositoryFormat.get_format_string()."""
 
1749
        return "Bazaar-NG Knit Repository Format 1"
 
1750
 
 
1751
    def get_format_description(self):
 
1752
        """See RepositoryFormat.get_format_description()."""
 
1753
        return "Knit repository format 1"
 
1754
 
 
1755
    def check_conversion_target(self, target_format):
 
1756
        pass
 
1757
 
 
1758
 
 
1759
class RepositoryFormatKnit2(RepositoryFormatKnit):
 
1760
    """Bzr repository knit format 2.
 
1761
 
 
1762
    THIS FORMAT IS EXPERIMENTAL
 
1763
    This repository format has:
 
1764
     - knits for file texts and inventory
 
1765
     - hash subdirectory based stores.
 
1766
     - knits for revisions and signatures
 
1767
     - TextStores for revisions and signatures.
 
1768
     - a format marker of its own
 
1769
     - an optional 'shared-storage' flag
 
1770
     - an optional 'no-working-trees' flag
 
1771
     - a LockDir lock
 
1772
     - Support for recording full info about the tree root
 
1773
 
 
1774
    """
 
1775
    
 
1776
    rich_root_data = True
 
1777
 
 
1778
    def get_format_string(self):
 
1779
        """See RepositoryFormat.get_format_string()."""
 
1780
        return "Bazaar Knit Repository Format 2\n"
 
1781
 
 
1782
    def get_format_description(self):
 
1783
        """See RepositoryFormat.get_format_description()."""
 
1784
        return "Knit repository format 2"
 
1785
 
 
1786
    def check_conversion_target(self, target_format):
 
1787
        if not target_format.rich_root_data:
 
1788
            raise errors.BadConversionTarget(
 
1789
                'Does not support rich root data.', target_format)
 
1790
 
 
1791
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
1792
        """See RepositoryFormat.open().
 
1793
        
 
1794
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
1795
                                    repository at a slightly different url
 
1796
                                    than normal. I.e. during 'upgrade'.
 
1797
        """
 
1798
        if not _found:
 
1799
            format = RepositoryFormat.find_format(a_bzrdir)
 
1800
            assert format.__class__ ==  self.__class__
 
1801
        if _override_transport is not None:
 
1802
            repo_transport = _override_transport
 
1803
        else:
 
1804
            repo_transport = a_bzrdir.get_repository_transport(None)
 
1805
        control_files = lockable_files.LockableFiles(repo_transport, 'lock',
 
1806
                                                     lockdir.LockDir)
 
1807
        text_store = self._get_text_store(repo_transport, control_files)
 
1808
        control_store = self._get_control_store(repo_transport, control_files)
 
1809
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1810
        return KnitRepository2(_format=self,
 
1811
                               a_bzrdir=a_bzrdir,
 
1812
                               control_files=control_files,
 
1813
                               _revision_store=_revision_store,
 
1814
                               control_store=control_store,
 
1815
                               text_store=text_store)
 
1816
 
 
1817
 
 
1818
 
 
1819
# formats which have no format string are not discoverable
 
1820
# and not independently creatable, so are not registered.
 
1821
RepositoryFormat.register_format(RepositoryFormat7())
 
1822
# KEEP in sync with bzrdir.format_registry default, which controls the overall
 
1823
# default control directory format
 
1824
_default_format = RepositoryFormatKnit1()
 
1825
RepositoryFormat.register_format(_default_format)
 
1826
RepositoryFormat.register_format(RepositoryFormatKnit2())
 
1827
RepositoryFormat._set_default_format(_default_format)
 
1828
_legacy_formats = [RepositoryFormat4(),
 
1829
                   RepositoryFormat5(),
 
1830
                   RepositoryFormat6()]
 
1831
 
 
1832
 
 
1833
class InterRepository(InterObject):
 
1834
    """This class represents operations taking place between two repositories.
 
1835
 
 
1836
    Its instances have methods like copy_content and fetch, and contain
 
1837
    references to the source and target repositories these operations can be 
 
1838
    carried out on.
 
1839
 
 
1840
    Often we will provide convenience methods on 'repository' which carry out
 
1841
    operations with another repository - they will always forward to
 
1842
    InterRepository.get(other).method_name(parameters).
 
1843
    """
 
1844
 
 
1845
    _optimisers = []
 
1846
    """The available optimised InterRepository types."""
 
1847
 
 
1848
    def copy_content(self, revision_id=None, basis=None):
 
1849
        raise NotImplementedError(self.copy_content)
 
1850
 
 
1851
    def fetch(self, revision_id=None, pb=None):
 
1852
        """Fetch the content required to construct revision_id.
 
1853
 
 
1854
        The content is copied from self.source to self.target.
 
1855
 
 
1856
        :param revision_id: if None all content is copied, if NULL_REVISION no
 
1857
                            content is copied.
 
1858
        :param pb: optional progress bar to use for progress reports. If not
 
1859
                   provided a default one will be created.
 
1860
 
 
1861
        Returns the copied revision count and the failed revisions in a tuple:
 
1862
        (copied, failures).
 
1863
        """
 
1864
        raise NotImplementedError(self.fetch)
 
1865
   
 
1866
    @needs_read_lock
 
1867
    def missing_revision_ids(self, revision_id=None):
 
1868
        """Return the revision ids that source has that target does not.
 
1869
        
 
1870
        These are returned in topological order.
 
1871
 
 
1872
        :param revision_id: only return revision ids included by this
 
1873
                            revision_id.
 
1874
        """
 
1875
        # generic, possibly worst case, slow code path.
 
1876
        target_ids = set(self.target.all_revision_ids())
 
1877
        if revision_id is not None:
 
1878
            source_ids = self.source.get_ancestry(revision_id)
 
1879
            assert source_ids[0] is None
 
1880
            source_ids.pop(0)
 
1881
        else:
 
1882
            source_ids = self.source.all_revision_ids()
 
1883
        result_set = set(source_ids).difference(target_ids)
 
1884
        # this may look like a no-op: its not. It preserves the ordering
 
1885
        # other_ids had while only returning the members from other_ids
 
1886
        # that we've decided we need.
 
1887
        return [rev_id for rev_id in source_ids if rev_id in result_set]
 
1888
 
 
1889
 
 
1890
class InterSameDataRepository(InterRepository):
 
1891
    """Code for converting between repositories that represent the same data.
 
1892
    
 
1893
    Data format and model must match for this to work.
 
1894
    """
 
1895
 
 
1896
    _matching_repo_format = RepositoryFormat4()
 
1897
    """Repository format for testing with."""
 
1898
 
 
1899
    @staticmethod
 
1900
    def is_compatible(source, target):
 
1901
        if not isinstance(source, Repository):
 
1902
            return False
 
1903
        if not isinstance(target, Repository):
 
1904
            return False
 
1905
        if source._format.rich_root_data == target._format.rich_root_data:
 
1906
            return True
 
1907
        else:
 
1908
            return False
 
1909
 
 
1910
    @needs_write_lock
 
1911
    def copy_content(self, revision_id=None, basis=None):
 
1912
        """Make a complete copy of the content in self into destination.
 
1913
        
 
1914
        This is a destructive operation! Do not use it on existing 
 
1915
        repositories.
 
1916
 
 
1917
        :param revision_id: Only copy the content needed to construct
 
1918
                            revision_id and its parents.
 
1919
        :param basis: Copy the needed data preferentially from basis.
 
1920
        """
 
1921
        try:
 
1922
            self.target.set_make_working_trees(self.source.make_working_trees())
 
1923
        except NotImplementedError:
 
1924
            pass
 
1925
        # grab the basis available data
 
1926
        if basis is not None:
 
1927
            self.target.fetch(basis, revision_id=revision_id)
 
1928
        # but don't bother fetching if we have the needed data now.
 
1929
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
1930
            self.target.has_revision(revision_id)):
 
1931
            return
 
1932
        self.target.fetch(self.source, revision_id=revision_id)
 
1933
 
 
1934
    @needs_write_lock
 
1935
    def fetch(self, revision_id=None, pb=None):
 
1936
        """See InterRepository.fetch()."""
 
1937
        from bzrlib.fetch import GenericRepoFetcher
 
1938
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1939
               self.source, self.source._format, self.target, 
 
1940
               self.target._format)
 
1941
        f = GenericRepoFetcher(to_repository=self.target,
 
1942
                               from_repository=self.source,
 
1943
                               last_revision=revision_id,
 
1944
                               pb=pb)
 
1945
        return f.count_copied, f.failed_revisions
 
1946
 
 
1947
 
 
1948
class InterWeaveRepo(InterSameDataRepository):
 
1949
    """Optimised code paths between Weave based repositories."""
 
1950
 
 
1951
    _matching_repo_format = RepositoryFormat7()
 
1952
    """Repository format for testing with."""
 
1953
 
 
1954
    @staticmethod
 
1955
    def is_compatible(source, target):
 
1956
        """Be compatible with known Weave formats.
 
1957
        
 
1958
        We don't test for the stores being of specific types because that
 
1959
        could lead to confusing results, and there is no need to be 
 
1960
        overly general.
 
1961
        """
 
1962
        try:
 
1963
            return (isinstance(source._format, (RepositoryFormat5,
 
1964
                                                RepositoryFormat6,
 
1965
                                                RepositoryFormat7)) and
 
1966
                    isinstance(target._format, (RepositoryFormat5,
 
1967
                                                RepositoryFormat6,
 
1968
                                                RepositoryFormat7)))
 
1969
        except AttributeError:
 
1970
            return False
 
1971
    
 
1972
    @needs_write_lock
 
1973
    def copy_content(self, revision_id=None, basis=None):
 
1974
        """See InterRepository.copy_content()."""
 
1975
        # weave specific optimised path:
 
1976
        if basis is not None:
 
1977
            # copy the basis in, then fetch remaining data.
 
1978
            basis.copy_content_into(self.target, revision_id)
 
1979
            # the basis copy_content_into could miss-set this.
 
1980
            try:
 
1981
                self.target.set_make_working_trees(self.source.make_working_trees())
 
1982
            except NotImplementedError:
 
1983
                pass
 
1984
            self.target.fetch(self.source, revision_id=revision_id)
 
1985
        else:
 
1986
            try:
 
1987
                self.target.set_make_working_trees(self.source.make_working_trees())
 
1988
            except NotImplementedError:
 
1989
                pass
 
1990
            # FIXME do not peek!
 
1991
            if self.source.control_files._transport.listable():
 
1992
                pb = ui.ui_factory.nested_progress_bar()
 
1993
                try:
 
1994
                    self.target.weave_store.copy_all_ids(
 
1995
                        self.source.weave_store,
 
1996
                        pb=pb,
 
1997
                        from_transaction=self.source.get_transaction(),
 
1998
                        to_transaction=self.target.get_transaction())
 
1999
                    pb.update('copying inventory', 0, 1)
 
2000
                    self.target.control_weaves.copy_multi(
 
2001
                        self.source.control_weaves, ['inventory'],
 
2002
                        from_transaction=self.source.get_transaction(),
 
2003
                        to_transaction=self.target.get_transaction())
 
2004
                    self.target._revision_store.text_store.copy_all_ids(
 
2005
                        self.source._revision_store.text_store,
 
2006
                        pb=pb)
 
2007
                finally:
 
2008
                    pb.finished()
 
2009
            else:
 
2010
                self.target.fetch(self.source, revision_id=revision_id)
 
2011
 
 
2012
    @needs_write_lock
 
2013
    def fetch(self, revision_id=None, pb=None):
 
2014
        """See InterRepository.fetch()."""
 
2015
        from bzrlib.fetch import GenericRepoFetcher
 
2016
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2017
               self.source, self.source._format, self.target, self.target._format)
 
2018
        f = GenericRepoFetcher(to_repository=self.target,
 
2019
                               from_repository=self.source,
 
2020
                               last_revision=revision_id,
 
2021
                               pb=pb)
 
2022
        return f.count_copied, f.failed_revisions
 
2023
 
 
2024
    @needs_read_lock
 
2025
    def missing_revision_ids(self, revision_id=None):
 
2026
        """See InterRepository.missing_revision_ids()."""
 
2027
        # we want all revisions to satisfy revision_id in source.
 
2028
        # but we don't want to stat every file here and there.
 
2029
        # we want then, all revisions other needs to satisfy revision_id 
 
2030
        # checked, but not those that we have locally.
 
2031
        # so the first thing is to get a subset of the revisions to 
 
2032
        # satisfy revision_id in source, and then eliminate those that
 
2033
        # we do already have. 
 
2034
        # this is slow on high latency connection to self, but as as this
 
2035
        # disk format scales terribly for push anyway due to rewriting 
 
2036
        # inventory.weave, this is considered acceptable.
 
2037
        # - RBC 20060209
 
2038
        if revision_id is not None:
 
2039
            source_ids = self.source.get_ancestry(revision_id)
 
2040
            assert source_ids[0] is None
 
2041
            source_ids.pop(0)
 
2042
        else:
 
2043
            source_ids = self.source._all_possible_ids()
 
2044
        source_ids_set = set(source_ids)
 
2045
        # source_ids is the worst possible case we may need to pull.
 
2046
        # now we want to filter source_ids against what we actually
 
2047
        # have in target, but don't try to check for existence where we know
 
2048
        # we do not have a revision as that would be pointless.
 
2049
        target_ids = set(self.target._all_possible_ids())
 
2050
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
2051
        actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
2052
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
2053
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
 
2054
        if revision_id is not None:
 
2055
            # we used get_ancestry to determine source_ids then we are assured all
 
2056
            # revisions referenced are present as they are installed in topological order.
 
2057
            # and the tip revision was validated by get_ancestry.
 
2058
            return required_topo_revisions
 
2059
        else:
 
2060
            # if we just grabbed the possibly available ids, then 
 
2061
            # we only have an estimate of whats available and need to validate
 
2062
            # that against the revision records.
 
2063
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
 
2064
 
 
2065
 
 
2066
class InterKnitRepo(InterSameDataRepository):
 
2067
    """Optimised code paths between Knit based repositories."""
 
2068
 
 
2069
    _matching_repo_format = RepositoryFormatKnit1()
 
2070
    """Repository format for testing with."""
 
2071
 
 
2072
    @staticmethod
 
2073
    def is_compatible(source, target):
 
2074
        """Be compatible with known Knit formats.
 
2075
        
 
2076
        We don't test for the stores being of specific types because that
 
2077
        could lead to confusing results, and there is no need to be 
 
2078
        overly general.
 
2079
        """
 
2080
        try:
 
2081
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
 
2082
                    isinstance(target._format, (RepositoryFormatKnit1)))
 
2083
        except AttributeError:
 
2084
            return False
 
2085
 
 
2086
    @needs_write_lock
 
2087
    def fetch(self, revision_id=None, pb=None):
 
2088
        """See InterRepository.fetch()."""
 
2089
        from bzrlib.fetch import KnitRepoFetcher
 
2090
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2091
               self.source, self.source._format, self.target, self.target._format)
 
2092
        f = KnitRepoFetcher(to_repository=self.target,
 
2093
                            from_repository=self.source,
 
2094
                            last_revision=revision_id,
 
2095
                            pb=pb)
 
2096
        return f.count_copied, f.failed_revisions
 
2097
 
 
2098
    @needs_read_lock
 
2099
    def missing_revision_ids(self, revision_id=None):
 
2100
        """See InterRepository.missing_revision_ids()."""
 
2101
        if revision_id is not None:
 
2102
            source_ids = self.source.get_ancestry(revision_id)
 
2103
            assert source_ids[0] is None
 
2104
            source_ids.pop(0)
 
2105
        else:
 
2106
            source_ids = self.source._all_possible_ids()
 
2107
        source_ids_set = set(source_ids)
 
2108
        # source_ids is the worst possible case we may need to pull.
 
2109
        # now we want to filter source_ids against what we actually
 
2110
        # have in target, but don't try to check for existence where we know
 
2111
        # we do not have a revision as that would be pointless.
 
2112
        target_ids = set(self.target._all_possible_ids())
 
2113
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
2114
        actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
2115
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
2116
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
 
2117
        if revision_id is not None:
 
2118
            # we used get_ancestry to determine source_ids then we are assured all
 
2119
            # revisions referenced are present as they are installed in topological order.
 
2120
            # and the tip revision was validated by get_ancestry.
 
2121
            return required_topo_revisions
 
2122
        else:
 
2123
            # if we just grabbed the possibly available ids, then 
 
2124
            # we only have an estimate of whats available and need to validate
 
2125
            # that against the revision records.
 
2126
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
 
2127
 
 
2128
 
 
2129
class InterModel1and2(InterRepository):
 
2130
 
 
2131
    _matching_repo_format = None
 
2132
 
 
2133
    @staticmethod
 
2134
    def is_compatible(source, target):
 
2135
        if not isinstance(source, Repository):
 
2136
            return False
 
2137
        if not isinstance(target, Repository):
 
2138
            return False
 
2139
        if not source._format.rich_root_data and target._format.rich_root_data:
 
2140
            return True
 
2141
        else:
 
2142
            return False
 
2143
 
 
2144
    @needs_write_lock
 
2145
    def fetch(self, revision_id=None, pb=None):
 
2146
        """See InterRepository.fetch()."""
 
2147
        from bzrlib.fetch import Model1toKnit2Fetcher
 
2148
        f = Model1toKnit2Fetcher(to_repository=self.target,
 
2149
                                 from_repository=self.source,
 
2150
                                 last_revision=revision_id,
 
2151
                                 pb=pb)
 
2152
        return f.count_copied, f.failed_revisions
 
2153
 
 
2154
    @needs_write_lock
 
2155
    def copy_content(self, revision_id=None, basis=None):
 
2156
        """Make a complete copy of the content in self into destination.
 
2157
        
 
2158
        This is a destructive operation! Do not use it on existing 
 
2159
        repositories.
 
2160
 
 
2161
        :param revision_id: Only copy the content needed to construct
 
2162
                            revision_id and its parents.
 
2163
        :param basis: Copy the needed data preferentially from basis.
 
2164
        """
 
2165
        try:
 
2166
            self.target.set_make_working_trees(self.source.make_working_trees())
 
2167
        except NotImplementedError:
 
2168
            pass
 
2169
        # grab the basis available data
 
2170
        if basis is not None:
 
2171
            self.target.fetch(basis, revision_id=revision_id)
 
2172
        # but don't bother fetching if we have the needed data now.
 
2173
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
 
2174
            self.target.has_revision(revision_id)):
 
2175
            return
 
2176
        self.target.fetch(self.source, revision_id=revision_id)
 
2177
 
 
2178
 
 
2179
class InterKnit1and2(InterKnitRepo):
 
2180
 
 
2181
    _matching_repo_format = None
 
2182
 
 
2183
    @staticmethod
 
2184
    def is_compatible(source, target):
 
2185
        """Be compatible with Knit1 source and Knit2 target"""
 
2186
        try:
 
2187
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
 
2188
                    isinstance(target._format, (RepositoryFormatKnit2)))
 
2189
        except AttributeError:
 
2190
            return False
 
2191
 
 
2192
    @needs_write_lock
 
2193
    def fetch(self, revision_id=None, pb=None):
 
2194
        """See InterRepository.fetch()."""
 
2195
        from bzrlib.fetch import Knit1to2Fetcher
 
2196
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
2197
               self.source, self.source._format, self.target, 
 
2198
               self.target._format)
 
2199
        f = Knit1to2Fetcher(to_repository=self.target,
 
2200
                            from_repository=self.source,
 
2201
                            last_revision=revision_id,
 
2202
                            pb=pb)
 
2203
        return f.count_copied, f.failed_revisions
 
2204
 
 
2205
 
 
2206
InterRepository.register_optimiser(InterSameDataRepository)
 
2207
InterRepository.register_optimiser(InterWeaveRepo)
 
2208
InterRepository.register_optimiser(InterKnitRepo)
 
2209
InterRepository.register_optimiser(InterModel1and2)
 
2210
InterRepository.register_optimiser(InterKnit1and2)
 
2211
 
 
2212
 
 
2213
class RepositoryTestProviderAdapter(object):
 
2214
    """A tool to generate a suite testing multiple repository formats at once.
 
2215
 
 
2216
    This is done by copying the test once for each transport and injecting
 
2217
    the transport_server, transport_readonly_server, and bzrdir_format and
 
2218
    repository_format classes into each copy. Each copy is also given a new id()
 
2219
    to make it easy to identify.
 
2220
    """
 
2221
 
 
2222
    def __init__(self, transport_server, transport_readonly_server, formats):
 
2223
        self._transport_server = transport_server
 
2224
        self._transport_readonly_server = transport_readonly_server
 
2225
        self._formats = formats
 
2226
    
 
2227
    def adapt(self, test):
 
2228
        result = unittest.TestSuite()
 
2229
        for repository_format, bzrdir_format in self._formats:
 
2230
            new_test = deepcopy(test)
 
2231
            new_test.transport_server = self._transport_server
 
2232
            new_test.transport_readonly_server = self._transport_readonly_server
 
2233
            new_test.bzrdir_format = bzrdir_format
 
2234
            new_test.repository_format = repository_format
 
2235
            def make_new_test_id():
 
2236
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
 
2237
                return lambda: new_id
 
2238
            new_test.id = make_new_test_id()
 
2239
            result.addTest(new_test)
 
2240
        return result
 
2241
 
 
2242
 
 
2243
class InterRepositoryTestProviderAdapter(object):
 
2244
    """A tool to generate a suite testing multiple inter repository formats.
 
2245
 
 
2246
    This is done by copying the test once for each interrepo provider and injecting
 
2247
    the transport_server, transport_readonly_server, repository_format and 
 
2248
    repository_to_format classes into each copy.
 
2249
    Each copy is also given a new id() to make it easy to identify.
 
2250
    """
 
2251
 
 
2252
    def __init__(self, transport_server, transport_readonly_server, formats):
 
2253
        self._transport_server = transport_server
 
2254
        self._transport_readonly_server = transport_readonly_server
 
2255
        self._formats = formats
 
2256
    
 
2257
    def adapt(self, test):
 
2258
        result = unittest.TestSuite()
 
2259
        for interrepo_class, repository_format, repository_format_to in self._formats:
 
2260
            new_test = deepcopy(test)
 
2261
            new_test.transport_server = self._transport_server
 
2262
            new_test.transport_readonly_server = self._transport_readonly_server
 
2263
            new_test.interrepo_class = interrepo_class
 
2264
            new_test.repository_format = repository_format
 
2265
            new_test.repository_format_to = repository_format_to
 
2266
            def make_new_test_id():
 
2267
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
 
2268
                return lambda: new_id
 
2269
            new_test.id = make_new_test_id()
 
2270
            result.addTest(new_test)
 
2271
        return result
 
2272
 
 
2273
    @staticmethod
 
2274
    def default_test_list():
 
2275
        """Generate the default list of interrepo permutations to test."""
 
2276
        result = []
 
2277
        # test the default InterRepository between format 6 and the current 
 
2278
        # default format.
 
2279
        # XXX: robertc 20060220 reinstate this when there are two supported
 
2280
        # formats which do not have an optimal code path between them.
 
2281
        #result.append((InterRepository,
 
2282
        #               RepositoryFormat6(),
 
2283
        #               RepositoryFormatKnit1()))
 
2284
        for optimiser in InterRepository._optimisers:
 
2285
            if optimiser._matching_repo_format is not None:
 
2286
                result.append((optimiser,
 
2287
                               optimiser._matching_repo_format,
 
2288
                               optimiser._matching_repo_format
 
2289
                               ))
 
2290
        # if there are specific combinations we want to use, we can add them 
 
2291
        # here.
 
2292
        result.append((InterModel1and2, RepositoryFormat5(),
 
2293
                       RepositoryFormatKnit2()))
 
2294
        result.append((InterKnit1and2, RepositoryFormatKnit1(),
 
2295
                       RepositoryFormatKnit2()))
 
2296
        return result
 
2297
 
 
2298
 
 
2299
class CopyConverter(object):
 
2300
    """A repository conversion tool which just performs a copy of the content.
 
2301
    
 
2302
    This is slow but quite reliable.
 
2303
    """
 
2304
 
 
2305
    def __init__(self, target_format):
 
2306
        """Create a CopyConverter.
 
2307
 
 
2308
        :param target_format: The format the resulting repository should be.
 
2309
        """
 
2310
        self.target_format = target_format
 
2311
        
 
2312
    def convert(self, repo, pb):
 
2313
        """Perform the conversion of to_convert, giving feedback via pb.
 
2314
 
 
2315
        :param to_convert: The disk object to convert.
 
2316
        :param pb: a progress bar to use for progress information.
 
2317
        """
 
2318
        self.pb = pb
 
2319
        self.count = 0
 
2320
        self.total = 4
 
2321
        # this is only useful with metadir layouts - separated repo content.
 
2322
        # trigger an assertion if not such
 
2323
        repo._format.get_format_string()
 
2324
        self.repo_dir = repo.bzrdir
 
2325
        self.step('Moving repository to repository.backup')
 
2326
        self.repo_dir.transport.move('repository', 'repository.backup')
 
2327
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
 
2328
        repo._format.check_conversion_target(self.target_format)
 
2329
        self.source_repo = repo._format.open(self.repo_dir,
 
2330
            _found=True,
 
2331
            _override_transport=backup_transport)
 
2332
        self.step('Creating new repository')
 
2333
        converted = self.target_format.initialize(self.repo_dir,
 
2334
                                                  self.source_repo.is_shared())
 
2335
        converted.lock_write()
 
2336
        try:
 
2337
            self.step('Copying content into repository.')
 
2338
            self.source_repo.copy_content_into(converted)
 
2339
        finally:
 
2340
            converted.unlock()
 
2341
        self.step('Deleting old repository content.')
 
2342
        self.repo_dir.transport.delete_tree('repository.backup')
 
2343
        self.pb.note('repository converted')
 
2344
 
 
2345
    def step(self, message):
 
2346
        """Update the pb by a step."""
 
2347
        self.count +=1
 
2348
        self.pb.update(message, self.count, self.total)
 
2349
 
 
2350
 
 
2351
class CommitBuilder(object):
 
2352
    """Provides an interface to build up a commit.
 
2353
 
 
2354
    This allows describing a tree to be committed without needing to 
 
2355
    know the internals of the format of the repository.
 
2356
    """
 
2357
    
 
2358
    record_root_entry = False
 
2359
    def __init__(self, repository, parents, config, timestamp=None, 
 
2360
                 timezone=None, committer=None, revprops=None, 
 
2361
                 revision_id=None):
 
2362
        """Initiate a CommitBuilder.
 
2363
 
 
2364
        :param repository: Repository to commit to.
 
2365
        :param parents: Revision ids of the parents of the new revision.
 
2366
        :param config: Configuration to use.
 
2367
        :param timestamp: Optional timestamp recorded for commit.
 
2368
        :param timezone: Optional timezone for timestamp.
 
2369
        :param committer: Optional committer to set for commit.
 
2370
        :param revprops: Optional dictionary of revision properties.
 
2371
        :param revision_id: Optional revision id.
 
2372
        """
 
2373
        self._config = config
 
2374
 
 
2375
        if committer is None:
 
2376
            self._committer = self._config.username()
 
2377
        else:
 
2378
            assert isinstance(committer, basestring), type(committer)
 
2379
            self._committer = committer
 
2380
 
 
2381
        self.new_inventory = Inventory(None)
 
2382
        self._new_revision_id = revision_id
 
2383
        self.parents = parents
 
2384
        self.repository = repository
 
2385
 
 
2386
        self._revprops = {}
 
2387
        if revprops is not None:
 
2388
            self._revprops.update(revprops)
 
2389
 
 
2390
        if timestamp is None:
 
2391
            timestamp = time.time()
 
2392
        # Restrict resolution to 1ms
 
2393
        self._timestamp = round(timestamp, 3)
 
2394
 
 
2395
        if timezone is None:
 
2396
            self._timezone = local_time_offset()
 
2397
        else:
 
2398
            self._timezone = int(timezone)
 
2399
 
 
2400
        self._generate_revision_if_needed()
 
2401
 
 
2402
    def commit(self, message):
 
2403
        """Make the actual commit.
 
2404
 
 
2405
        :return: The revision id of the recorded revision.
 
2406
        """
 
2407
        rev = _mod_revision.Revision(
 
2408
                       timestamp=self._timestamp,
 
2409
                       timezone=self._timezone,
 
2410
                       committer=self._committer,
 
2411
                       message=message,
 
2412
                       inventory_sha1=self.inv_sha1,
 
2413
                       revision_id=self._new_revision_id,
 
2414
                       properties=self._revprops)
 
2415
        rev.parent_ids = self.parents
 
2416
        self.repository.add_revision(self._new_revision_id, rev, 
 
2417
            self.new_inventory, self._config)
 
2418
        return self._new_revision_id
 
2419
 
 
2420
    def revision_tree(self):
 
2421
        """Return the tree that was just committed.
 
2422
 
 
2423
        After calling commit() this can be called to get a RevisionTree
 
2424
        representing the newly committed tree. This is preferred to
 
2425
        calling Repository.revision_tree() because that may require
 
2426
        deserializing the inventory, while we already have a copy in
 
2427
        memory.
 
2428
        """
 
2429
        return RevisionTree(self.repository, self.new_inventory,
 
2430
                            self._new_revision_id)
 
2431
 
 
2432
    def finish_inventory(self):
 
2433
        """Tell the builder that the inventory is finished."""
 
2434
        if self.new_inventory.root is None:
 
2435
            symbol_versioning.warn('Root entry should be supplied to'
 
2436
                ' record_entry_contents, as of bzr 0.10.',
 
2437
                 DeprecationWarning, stacklevel=2)
 
2438
            self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
 
2439
        self.new_inventory.revision_id = self._new_revision_id
 
2440
        self.inv_sha1 = self.repository.add_inventory(
 
2441
            self._new_revision_id,
 
2442
            self.new_inventory,
 
2443
            self.parents
 
2444
            )
 
2445
 
 
2446
    def _gen_revision_id(self):
 
2447
        """Return new revision-id."""
 
2448
        return generate_ids.gen_revision_id(self._config.username(),
 
2449
                                            self._timestamp)
 
2450
 
 
2451
    def _generate_revision_if_needed(self):
 
2452
        """Create a revision id if None was supplied.
 
2453
        
 
2454
        If the repository can not support user-specified revision ids
 
2455
        they should override this function and raise CannotSetRevisionId
 
2456
        if _new_revision_id is not None.
 
2457
 
 
2458
        :raises: CannotSetRevisionId
 
2459
        """
 
2460
        if self._new_revision_id is None:
 
2461
            self._new_revision_id = self._gen_revision_id()
 
2462
 
 
2463
    def record_entry_contents(self, ie, parent_invs, path, tree):
 
2464
        """Record the content of ie from tree into the commit if needed.
 
2465
 
 
2466
        Side effect: sets ie.revision when unchanged
 
2467
 
 
2468
        :param ie: An inventory entry present in the commit.
 
2469
        :param parent_invs: The inventories of the parent revisions of the
 
2470
            commit.
 
2471
        :param path: The path the entry is at in the tree.
 
2472
        :param tree: The tree which contains this entry and should be used to 
 
2473
        obtain content.
 
2474
        """
 
2475
        if self.new_inventory.root is None and ie.parent_id is not None:
 
2476
            symbol_versioning.warn('Root entry should be supplied to'
 
2477
                ' record_entry_contents, as of bzr 0.10.',
 
2478
                 DeprecationWarning, stacklevel=2)
 
2479
            self.record_entry_contents(tree.inventory.root.copy(), parent_invs,
 
2480
                                       '', tree)
 
2481
        self.new_inventory.add(ie)
 
2482
 
 
2483
        # ie.revision is always None if the InventoryEntry is considered
 
2484
        # for committing. ie.snapshot will record the correct revision 
 
2485
        # which may be the sole parent if it is untouched.
 
2486
        if ie.revision is not None:
 
2487
            return
 
2488
 
 
2489
        # In this revision format, root entries have no knit or weave
 
2490
        if ie is self.new_inventory.root:
 
2491
            # When serializing out to disk and back in
 
2492
            # root.revision is always _new_revision_id
 
2493
            ie.revision = self._new_revision_id
 
2494
            return
 
2495
        previous_entries = ie.find_previous_heads(
 
2496
            parent_invs,
 
2497
            self.repository.weave_store,
 
2498
            self.repository.get_transaction())
 
2499
        # we are creating a new revision for ie in the history store
 
2500
        # and inventory.
 
2501
        ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
 
2502
 
 
2503
    def modified_directory(self, file_id, file_parents):
 
2504
        """Record the presence of a symbolic link.
 
2505
 
 
2506
        :param file_id: The file_id of the link to record.
 
2507
        :param file_parents: The per-file parent revision ids.
 
2508
        """
 
2509
        self._add_text_to_weave(file_id, [], file_parents.keys())
 
2510
    
 
2511
    def modified_file_text(self, file_id, file_parents,
 
2512
                           get_content_byte_lines, text_sha1=None,
 
2513
                           text_size=None):
 
2514
        """Record the text of file file_id
 
2515
 
 
2516
        :param file_id: The file_id of the file to record the text of.
 
2517
        :param file_parents: The per-file parent revision ids.
 
2518
        :param get_content_byte_lines: A callable which will return the byte
 
2519
            lines for the file.
 
2520
        :param text_sha1: Optional SHA1 of the file contents.
 
2521
        :param text_size: Optional size of the file contents.
 
2522
        """
 
2523
        # mutter('storing text of file {%s} in revision {%s} into %r',
 
2524
        #        file_id, self._new_revision_id, self.repository.weave_store)
 
2525
        # special case to avoid diffing on renames or 
 
2526
        # reparenting
 
2527
        if (len(file_parents) == 1
 
2528
            and text_sha1 == file_parents.values()[0].text_sha1
 
2529
            and text_size == file_parents.values()[0].text_size):
 
2530
            previous_ie = file_parents.values()[0]
 
2531
            versionedfile = self.repository.weave_store.get_weave(file_id, 
 
2532
                self.repository.get_transaction())
 
2533
            versionedfile.clone_text(self._new_revision_id, 
 
2534
                previous_ie.revision, file_parents.keys())
 
2535
            return text_sha1, text_size
 
2536
        else:
 
2537
            new_lines = get_content_byte_lines()
 
2538
            # TODO: Rather than invoking sha_strings here, _add_text_to_weave
 
2539
            # should return the SHA1 and size
 
2540
            self._add_text_to_weave(file_id, new_lines, file_parents.keys())
 
2541
            return osutils.sha_strings(new_lines), \
 
2542
                sum(map(len, new_lines))
 
2543
 
 
2544
    def modified_link(self, file_id, file_parents, link_target):
 
2545
        """Record the presence of a symbolic link.
 
2546
 
 
2547
        :param file_id: The file_id of the link to record.
 
2548
        :param file_parents: The per-file parent revision ids.
 
2549
        :param link_target: Target location of this link.
 
2550
        """
 
2551
        self._add_text_to_weave(file_id, [], file_parents.keys())
 
2552
 
 
2553
    def _add_text_to_weave(self, file_id, new_lines, parents):
 
2554
        versionedfile = self.repository.weave_store.get_weave_or_empty(
 
2555
            file_id, self.repository.get_transaction())
 
2556
        versionedfile.add_lines(self._new_revision_id, parents, new_lines)
 
2557
        versionedfile.clear_cache()
 
2558
 
 
2559
 
 
2560
class _CommitBuilder(CommitBuilder):
 
2561
    """Temporary class so old CommitBuilders are detected properly
 
2562
    
 
2563
    Note: CommitBuilder works whether or not root entry is recorded.
 
2564
    """
 
2565
 
 
2566
    record_root_entry = True
 
2567
 
 
2568
 
 
2569
class RootCommitBuilder(CommitBuilder):
 
2570
    """This commitbuilder actually records the root id"""
 
2571
    
 
2572
    record_root_entry = True
 
2573
 
 
2574
    def record_entry_contents(self, ie, parent_invs, path, tree):
 
2575
        """Record the content of ie from tree into the commit if needed.
 
2576
 
 
2577
        Side effect: sets ie.revision when unchanged
 
2578
 
 
2579
        :param ie: An inventory entry present in the commit.
 
2580
        :param parent_invs: The inventories of the parent revisions of the
 
2581
            commit.
 
2582
        :param path: The path the entry is at in the tree.
 
2583
        :param tree: The tree which contains this entry and should be used to 
 
2584
        obtain content.
 
2585
        """
 
2586
        assert self.new_inventory.root is not None or ie.parent_id is None
 
2587
        self.new_inventory.add(ie)
 
2588
 
 
2589
        # ie.revision is always None if the InventoryEntry is considered
 
2590
        # for committing. ie.snapshot will record the correct revision 
 
2591
        # which may be the sole parent if it is untouched.
 
2592
        if ie.revision is not None:
 
2593
            return
 
2594
 
 
2595
        previous_entries = ie.find_previous_heads(
 
2596
            parent_invs,
 
2597
            self.repository.weave_store,
 
2598
            self.repository.get_transaction())
 
2599
        # we are creating a new revision for ie in the history store
 
2600
        # and inventory.
 
2601
        ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
 
2602
 
 
2603
 
 
2604
_unescape_map = {
 
2605
    'apos':"'",
 
2606
    'quot':'"',
 
2607
    'amp':'&',
 
2608
    'lt':'<',
 
2609
    'gt':'>'
 
2610
}
 
2611
 
 
2612
 
 
2613
def _unescaper(match, _map=_unescape_map):
 
2614
    return _map[match.group(1)]
 
2615
 
 
2616
 
 
2617
_unescape_re = None
 
2618
 
 
2619
 
 
2620
def _unescape_xml(data):
 
2621
    """Unescape predefined XML entities in a string of data."""
 
2622
    global _unescape_re
 
2623
    if _unescape_re is None:
 
2624
        _unescape_re = re.compile('\&([^;]*);')
 
2625
    return _unescape_re.sub(_unescaper, data)