/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

Teach Knit repositories how to handle ghosts without corrupting at all.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
 
1
# Copyright (C) 2005, 2006 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 copy import deepcopy
 
18
from cStringIO import StringIO
 
19
from unittest import TestSuite
 
20
import xml.sax.saxutils
 
21
 
 
22
import bzrlib.bzrdir as bzrdir
 
23
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
24
import bzrlib.errors as errors
 
25
from bzrlib.errors import InvalidRevisionId
 
26
import bzrlib.gpg as gpg
 
27
from bzrlib.graph import Graph
 
28
from bzrlib.inter import InterObject
 
29
from bzrlib.knit import KnitVersionedFile
 
30
from bzrlib.lockable_files import LockableFiles, TransportLock
 
31
from bzrlib.lockdir import LockDir
 
32
from bzrlib.osutils import safe_unicode
 
33
from bzrlib.revision import NULL_REVISION
 
34
from bzrlib.store.versioned import VersionedFileStore, WeaveStore
 
35
from bzrlib.store.text import TextStore
 
36
from bzrlib.symbol_versioning import *
 
37
from bzrlib.trace import mutter
 
38
from bzrlib.tree import RevisionTree
 
39
from bzrlib.tsort import topo_sort
 
40
from bzrlib.testament import Testament
 
41
from bzrlib.tree import EmptyTree
 
42
import bzrlib.ui
 
43
from bzrlib.weave import WeaveFile
 
44
import bzrlib.xml5
 
45
 
 
46
 
 
47
class Repository(object):
 
48
    """Repository holding history for one or more branches.
 
49
 
 
50
    The repository holds and retrieves historical information including
 
51
    revisions and file history.  It's normally accessed only by the Branch,
 
52
    which views a particular line of development through that history.
 
53
 
 
54
    The Repository builds on top of Stores and a Transport, which respectively 
 
55
    describe the disk data format and the way of accessing the (possibly 
 
56
    remote) disk.
 
57
    """
 
58
 
 
59
    @needs_write_lock
 
60
    def add_inventory(self, revid, inv, parents):
 
61
        """Add the inventory inv to the repository as revid.
 
62
        
 
63
        :param parents: The revision ids of the parents that revid
 
64
                        is known to have and are in the repository already.
 
65
 
 
66
        returns the sha1 of the serialized inventory.
 
67
        """
 
68
        inv_text = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
69
        inv_sha1 = bzrlib.osutils.sha_string(inv_text)
 
70
        inv_vf = self.control_weaves.get_weave('inventory',
 
71
                                               self.get_transaction())
 
72
        inv_vf.add_lines(revid, parents, bzrlib.osutils.split_lines(inv_text))
 
73
        return inv_sha1
 
74
 
 
75
    @needs_write_lock
 
76
    def add_revision(self, rev_id, rev, inv=None, config=None):
 
77
        """Add rev to the revision store as rev_id.
 
78
 
 
79
        :param rev_id: the revision id to use.
 
80
        :param rev: The revision object.
 
81
        :param inv: The inventory for the revision. if None, it will be looked
 
82
                    up in the inventory storer
 
83
        :param config: If None no digital signature will be created.
 
84
                       If supplied its signature_needed method will be used
 
85
                       to determine if a signature should be made.
 
86
        """
 
87
        if config is not None and config.signature_needed():
 
88
            if inv is None:
 
89
                inv = self.get_inventory(rev_id)
 
90
            plaintext = Testament(rev, inv).as_short_text()
 
91
            self.store_revision_signature(
 
92
                gpg.GPGStrategy(config), plaintext, rev_id)
 
93
        if not rev_id in self.get_inventory_weave():
 
94
            if inv is None:
 
95
                raise errors.WeaveRevisionNotPresent(rev_id,
 
96
                                                     self.get_inventory_weave())
 
97
            else:
 
98
                # yes, this is not suitable for adding with ghosts.
 
99
                self.add_inventory(rev_id, inv, rev.parent_ids)
 
100
        self._revision_store.add_revision(rev, self.get_transaction())   
 
101
 
 
102
    @needs_read_lock
 
103
    def _all_possible_ids(self):
 
104
        """Return all the possible revisions that we could find."""
 
105
        return self.get_inventory_weave().versions()
 
106
 
 
107
    @needs_read_lock
 
108
    def all_revision_ids(self):
 
109
        """Returns a list of all the revision ids in the repository. 
 
110
 
 
111
        These are in as much topological order as the underlying store can 
 
112
        present: for weaves ghosts may lead to a lack of correctness until
 
113
        the reweave updates the parents list.
 
114
        """
 
115
        if self._revision_store.text_store.listable():
 
116
            return self._revision_store.all_revision_ids(self.get_transaction())
 
117
        result = self._all_possible_ids()
 
118
        return self._eliminate_revisions_not_present(result)
 
119
 
 
120
    @needs_read_lock
 
121
    def _eliminate_revisions_not_present(self, revision_ids):
 
122
        """Check every revision id in revision_ids to see if we have it.
 
123
 
 
124
        Returns a set of the present revisions.
 
125
        """
 
126
        result = []
 
127
        for id in revision_ids:
 
128
            if self.has_revision(id):
 
129
               result.append(id)
 
130
        return result
 
131
 
 
132
    @staticmethod
 
133
    def create(a_bzrdir):
 
134
        """Construct the current default format repository in a_bzrdir."""
 
135
        return RepositoryFormat.get_default_format().initialize(a_bzrdir)
 
136
 
 
137
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
 
138
        """instantiate a Repository.
 
139
 
 
140
        :param _format: The format of the repository on disk.
 
141
        :param a_bzrdir: The BzrDir of the repository.
 
142
 
 
143
        In the future we will have a single api for all stores for
 
144
        getting file texts, inventories and revisions, then
 
145
        this construct will accept instances of those things.
 
146
        """
 
147
        object.__init__(self)
 
148
        self._format = _format
 
149
        # the following are part of the public API for Repository:
 
150
        self.bzrdir = a_bzrdir
 
151
        self.control_files = control_files
 
152
        self._revision_store = _revision_store
 
153
        self.text_store = text_store
 
154
        # backwards compatability
 
155
        self.weave_store = text_store
 
156
        # not right yet - should be more semantically clear ? 
 
157
        # 
 
158
        self.control_store = control_store
 
159
        self.control_weaves = control_store
 
160
 
 
161
    def lock_write(self):
 
162
        self.control_files.lock_write()
 
163
 
 
164
    def lock_read(self):
 
165
        self.control_files.lock_read()
 
166
 
 
167
    def is_locked(self):
 
168
        return self.control_files.is_locked()
 
169
 
 
170
    @needs_read_lock
 
171
    def missing_revision_ids(self, other, revision_id=None):
 
172
        """Return the revision ids that other has that this does not.
 
173
        
 
174
        These are returned in topological order.
 
175
 
 
176
        revision_id: only return revision ids included by revision_id.
 
177
        """
 
178
        return InterRepository.get(other, self).missing_revision_ids(revision_id)
 
179
 
 
180
    @staticmethod
 
181
    def open(base):
 
182
        """Open the repository rooted at base.
 
183
 
 
184
        For instance, if the repository is at URL/.bzr/repository,
 
185
        Repository.open(URL) -> a Repository instance.
 
186
        """
 
187
        control = bzrlib.bzrdir.BzrDir.open(base)
 
188
        return control.open_repository()
 
189
 
 
190
    def copy_content_into(self, destination, revision_id=None, basis=None):
 
191
        """Make a complete copy of the content in self into destination.
 
192
        
 
193
        This is a destructive operation! Do not use it on existing 
 
194
        repositories.
 
195
        """
 
196
        return InterRepository.get(self, destination).copy_content(revision_id, basis)
 
197
 
 
198
    def fetch(self, source, revision_id=None, pb=None):
 
199
        """Fetch the content required to construct revision_id from source.
 
200
 
 
201
        If revision_id is None all content is copied.
 
202
        """
 
203
        return InterRepository.get(source, self).fetch(revision_id=revision_id,
 
204
                                                       pb=pb)
 
205
 
 
206
    def unlock(self):
 
207
        self.control_files.unlock()
 
208
 
 
209
    @needs_read_lock
 
210
    def clone(self, a_bzrdir, revision_id=None, basis=None):
 
211
        """Clone this repository into a_bzrdir using the current format.
 
212
 
 
213
        Currently no check is made that the format of this repository and
 
214
        the bzrdir format are compatible. FIXME RBC 20060201.
 
215
        """
 
216
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
 
217
            # use target default format.
 
218
            result = a_bzrdir.create_repository()
 
219
        # FIXME RBC 20060209 split out the repository type to avoid this check ?
 
220
        elif isinstance(a_bzrdir._format,
 
221
                      (bzrlib.bzrdir.BzrDirFormat4,
 
222
                       bzrlib.bzrdir.BzrDirFormat5,
 
223
                       bzrlib.bzrdir.BzrDirFormat6)):
 
224
            result = a_bzrdir.open_repository()
 
225
        else:
 
226
            result = self._format.initialize(a_bzrdir, shared=self.is_shared())
 
227
        self.copy_content_into(result, revision_id, basis)
 
228
        return result
 
229
 
 
230
    @needs_read_lock
 
231
    def has_revision(self, revision_id):
 
232
        """True if this repository has a copy of the revision."""
 
233
        return self._revision_store.has_revision_id(revision_id,
 
234
                                                    self.get_transaction())
 
235
 
 
236
    @needs_read_lock
 
237
    def get_revision_reconcile(self, revision_id):
 
238
        """'reconcile' helper routine that allows access to a revision always.
 
239
        
 
240
        This variant of get_revision does not cross check the weave graph
 
241
        against the revision one as get_revision does: but it should only
 
242
        be used by reconcile, or reconcile-alike commands that are correcting
 
243
        or testing the revision graph.
 
244
        """
 
245
        if not revision_id or not isinstance(revision_id, basestring):
 
246
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
 
247
        return self._revision_store.get_revision(revision_id,
 
248
                                                 self.get_transaction())
 
249
 
 
250
    @needs_read_lock
 
251
    def get_revision_xml(self, revision_id):
 
252
        rev = self.get_revision(revision_id) 
 
253
        rev_tmp = StringIO()
 
254
        # the current serializer..
 
255
        self._revision_store._serializer.write_revision(rev, rev_tmp)
 
256
        rev_tmp.seek(0)
 
257
        return rev_tmp.getvalue()
 
258
 
 
259
    @needs_read_lock
 
260
    def get_revision(self, revision_id):
 
261
        """Return the Revision object for a named revision"""
 
262
        r = self.get_revision_reconcile(revision_id)
 
263
        # weave corruption can lead to absent revision markers that should be
 
264
        # present.
 
265
        # the following test is reasonably cheap (it needs a single weave read)
 
266
        # and the weave is cached in read transactions. In write transactions
 
267
        # it is not cached but typically we only read a small number of
 
268
        # revisions. For knits when they are introduced we will probably want
 
269
        # to ensure that caching write transactions are in use.
 
270
        inv = self.get_inventory_weave()
 
271
        self._check_revision_parents(r, inv)
 
272
        return r
 
273
 
 
274
    def _check_revision_parents(self, revision, inventory):
 
275
        """Private to Repository and Fetch.
 
276
        
 
277
        This checks the parentage of revision in an inventory weave for 
 
278
        consistency and is only applicable to inventory-weave-for-ancestry
 
279
        using repository formats & fetchers.
 
280
        """
 
281
        weave_parents = inventory.get_parents(revision.revision_id)
 
282
        weave_names = inventory.versions()
 
283
        for parent_id in revision.parent_ids:
 
284
            if parent_id in weave_names:
 
285
                # this parent must not be a ghost.
 
286
                if not parent_id in weave_parents:
 
287
                    # but it is a ghost
 
288
                    raise errors.CorruptRepository(self)
 
289
 
 
290
    @needs_write_lock
 
291
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
 
292
        signature = gpg_strategy.sign(plaintext)
 
293
        self._revision_store.add_revision_signature_text(revision_id,
 
294
                                                         signature,
 
295
                                                         self.get_transaction())
 
296
 
 
297
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
298
        """Find file_id(s) which are involved in the changes between revisions.
 
299
 
 
300
        This determines the set of revisions which are involved, and then
 
301
        finds all file ids affected by those revisions.
 
302
        """
 
303
        w = self.get_inventory_weave()
 
304
        from_set = set(w.get_ancestry(from_revid))
 
305
        to_set = set(w.get_ancestry(to_revid))
 
306
        changed = to_set.difference(from_set)
 
307
        return self._fileid_involved_by_set(changed)
 
308
 
 
309
    def fileid_involved(self, last_revid=None):
 
310
        """Find all file_ids modified in the ancestry of last_revid.
 
311
 
 
312
        :param last_revid: If None, last_revision() will be used.
 
313
        """
 
314
        w = self.get_inventory_weave()
 
315
        if not last_revid:
 
316
            changed = set(w.versions())
 
317
        else:
 
318
            changed = set(w.get_ancestry(last_revid))
 
319
        return self._fileid_involved_by_set(changed)
 
320
 
 
321
    def fileid_involved_by_set(self, changes):
 
322
        """Find all file_ids modified by the set of revisions passed in.
 
323
 
 
324
        :param changes: A set() of revision ids
 
325
        """
 
326
        # TODO: jam 20060119 This line does *nothing*, remove it.
 
327
        #       or better yet, change _fileid_involved_by_set so
 
328
        #       that it takes the inventory weave, rather than
 
329
        #       pulling it out by itself.
 
330
        return self._fileid_involved_by_set(changes)
 
331
 
 
332
    def _fileid_involved_by_set(self, changes):
 
333
        """Find the set of file-ids affected by the set of revisions.
 
334
 
 
335
        :param changes: A set() of revision ids.
 
336
        :return: A set() of file ids.
 
337
        
 
338
        This peaks at the Weave, interpreting each line, looking to
 
339
        see if it mentions one of the revisions. And if so, includes
 
340
        the file id mentioned.
 
341
        This expects both the Weave format, and the serialization
 
342
        to have a single line per file/directory, and to have
 
343
        fileid="" and revision="" on that line.
 
344
        """
 
345
        assert isinstance(self._format, (RepositoryFormat5,
 
346
                                         RepositoryFormat6,
 
347
                                         RepositoryFormat7,
 
348
                                         RepositoryFormatKnit1)), \
 
349
            "fileid_involved only supported for branches which store inventory as unnested xml"
 
350
 
 
351
        w = self.get_inventory_weave()
 
352
        file_ids = set()
 
353
 
 
354
        # this code needs to read every line in every inventory for the
 
355
        # inventories [changes]. Seeing a line twice is ok. Seeing a line
 
356
        # not pesent in one of those inventories is unnecessary and not 
 
357
        # harmful because we are filtering by the revision id marker in the
 
358
        # inventory lines to only select file ids altered in one of those  
 
359
        # revisions. We dont need to see all lines in the inventory because
 
360
        # only those added in an inventory in rev X can contain a revision=X
 
361
        # line.
 
362
        for line in w.iter_lines_added_or_present_in_versions(changes):
 
363
            start = line.find('file_id="')+9
 
364
            if start < 9: continue
 
365
            end = line.find('"', start)
 
366
            assert end>= 0
 
367
            file_id = xml.sax.saxutils.unescape(line[start:end])
 
368
 
 
369
            # check if file_id is already present
 
370
            if file_id in file_ids: continue
 
371
 
 
372
            start = line.find('revision="')+10
 
373
            if start < 10: continue
 
374
            end = line.find('"', start)
 
375
            assert end>= 0
 
376
            revision_id = xml.sax.saxutils.unescape(line[start:end])
 
377
 
 
378
            if revision_id in changes:
 
379
                file_ids.add(file_id)
 
380
        return file_ids
 
381
 
 
382
    @needs_read_lock
 
383
    def get_inventory_weave(self):
 
384
        return self.control_weaves.get_weave('inventory',
 
385
            self.get_transaction())
 
386
 
 
387
    @needs_read_lock
 
388
    def get_inventory(self, revision_id):
 
389
        """Get Inventory object by hash."""
 
390
        xml = self.get_inventory_xml(revision_id)
 
391
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
 
392
 
 
393
    @needs_read_lock
 
394
    def get_inventory_xml(self, revision_id):
 
395
        """Get inventory XML as a file object."""
 
396
        try:
 
397
            assert isinstance(revision_id, basestring), type(revision_id)
 
398
            iw = self.get_inventory_weave()
 
399
            return iw.get_text(revision_id)
 
400
        except IndexError:
 
401
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
 
402
 
 
403
    @needs_read_lock
 
404
    def get_inventory_sha1(self, revision_id):
 
405
        """Return the sha1 hash of the inventory entry
 
406
        """
 
407
        return self.get_revision(revision_id).inventory_sha1
 
408
 
 
409
    @needs_read_lock
 
410
    def get_revision_graph(self, revision_id=None):
 
411
        """Return a dictionary containing the revision graph.
 
412
        
 
413
        :return: a dictionary of revision_id->revision_parents_list.
 
414
        """
 
415
        weave = self.get_inventory_weave()
 
416
        all_revisions = self._eliminate_revisions_not_present(weave.versions())
 
417
        entire_graph = dict([(node, weave.get_parents(node)) for 
 
418
                             node in all_revisions])
 
419
        if revision_id is None:
 
420
            return entire_graph
 
421
        elif revision_id not in entire_graph:
 
422
            raise errors.NoSuchRevision(self, revision_id)
 
423
        else:
 
424
            # add what can be reached from revision_id
 
425
            result = {}
 
426
            pending = set([revision_id])
 
427
            while len(pending) > 0:
 
428
                node = pending.pop()
 
429
                result[node] = entire_graph[node]
 
430
                for revision_id in result[node]:
 
431
                    if revision_id not in result:
 
432
                        pending.add(revision_id)
 
433
            return result
 
434
 
 
435
    @needs_read_lock
 
436
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
437
        """Return a graph of the revisions with ghosts marked as applicable.
 
438
 
 
439
        :param revision_ids: an iterable of revisions to graph or None for all.
 
440
        :return: a Graph object with the graph reachable from revision_ids.
 
441
        """
 
442
        result = Graph()
 
443
        if not revision_ids:
 
444
            pending = set(self.all_revision_ids())
 
445
            required = set([])
 
446
        else:
 
447
            pending = set(revision_ids)
 
448
            required = set(revision_ids)
 
449
        done = set([])
 
450
        while len(pending):
 
451
            revision_id = pending.pop()
 
452
            try:
 
453
                rev = self.get_revision(revision_id)
 
454
            except errors.NoSuchRevision:
 
455
                if revision_id in required:
 
456
                    raise
 
457
                # a ghost
 
458
                result.add_ghost(revision_id)
 
459
                continue
 
460
            for parent_id in rev.parent_ids:
 
461
                # is this queued or done ?
 
462
                if (parent_id not in pending and
 
463
                    parent_id not in done):
 
464
                    # no, queue it.
 
465
                    pending.add(parent_id)
 
466
            result.add_node(revision_id, rev.parent_ids)
 
467
            done.add(result)
 
468
        return result
 
469
 
 
470
    @needs_read_lock
 
471
    def get_revision_inventory(self, revision_id):
 
472
        """Return inventory of a past revision."""
 
473
        # TODO: Unify this with get_inventory()
 
474
        # bzr 0.0.6 and later imposes the constraint that the inventory_id
 
475
        # must be the same as its revision, so this is trivial.
 
476
        if revision_id is None:
 
477
            # This does not make sense: if there is no revision,
 
478
            # then it is the current tree inventory surely ?!
 
479
            # and thus get_root_id() is something that looks at the last
 
480
            # commit on the branch, and the get_root_id is an inventory check.
 
481
            raise NotImplementedError
 
482
            # return Inventory(self.get_root_id())
 
483
        else:
 
484
            return self.get_inventory(revision_id)
 
485
 
 
486
    @needs_read_lock
 
487
    def is_shared(self):
 
488
        """Return True if this repository is flagged as a shared repository."""
 
489
        # FIXME format 4-6 cannot be shared, this is technically faulty.
 
490
        return self.control_files._transport.has('shared-storage')
 
491
 
 
492
    @needs_write_lock
 
493
    def reconcile(self):
 
494
        """Reconcile this repository."""
 
495
        from bzrlib.reconcile import RepoReconciler
 
496
        reconciler = RepoReconciler(self)
 
497
        reconciler.reconcile()
 
498
        return reconciler
 
499
    
 
500
    @needs_read_lock
 
501
    def revision_tree(self, revision_id):
 
502
        """Return Tree for a revision on this branch.
 
503
 
 
504
        `revision_id` may be None for the null revision, in which case
 
505
        an `EmptyTree` is returned."""
 
506
        # TODO: refactor this to use an existing revision object
 
507
        # so we don't need to read it in twice.
 
508
        if revision_id is None or revision_id == NULL_REVISION:
 
509
            return EmptyTree()
 
510
        else:
 
511
            inv = self.get_revision_inventory(revision_id)
 
512
            return RevisionTree(self, inv, revision_id)
 
513
 
 
514
    @needs_read_lock
 
515
    def get_ancestry(self, revision_id):
 
516
        """Return a list of revision-ids integrated by a revision.
 
517
        
 
518
        This is topologically sorted.
 
519
        """
 
520
        if revision_id is None:
 
521
            return [None]
 
522
        if not self.has_revision(revision_id):
 
523
            raise errors.NoSuchRevision(self, revision_id)
 
524
        w = self.get_inventory_weave()
 
525
        candidates = w.get_ancestry(revision_id)
 
526
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
 
527
 
 
528
    @needs_read_lock
 
529
    def print_file(self, file, revision_id):
 
530
        """Print `file` to stdout.
 
531
        
 
532
        FIXME RBC 20060125 as John Meinel points out this is a bad api
 
533
        - it writes to stdout, it assumes that that is valid etc. Fix
 
534
        by creating a new more flexible convenience function.
 
535
        """
 
536
        tree = self.revision_tree(revision_id)
 
537
        # use inventory as it was in that revision
 
538
        file_id = tree.inventory.path2id(file)
 
539
        if not file_id:
 
540
            raise BzrError("%r is not present in revision %s" % (file, revno))
 
541
            try:
 
542
                revno = self.revision_id_to_revno(revision_id)
 
543
            except errors.NoSuchRevision:
 
544
                # TODO: This should not be BzrError,
 
545
                # but NoSuchFile doesn't fit either
 
546
                raise BzrError('%r is not present in revision %s' 
 
547
                                % (file, revision_id))
 
548
            else:
 
549
                raise BzrError('%r is not present in revision %s'
 
550
                                % (file, revno))
 
551
        tree.print_file(file_id)
 
552
 
 
553
    def get_transaction(self):
 
554
        return self.control_files.get_transaction()
 
555
 
 
556
    def revision_parents(self, revid):
 
557
        return self.get_inventory_weave().parent_names(revid)
 
558
 
 
559
    @needs_write_lock
 
560
    def set_make_working_trees(self, new_value):
 
561
        """Set the policy flag for making working trees when creating branches.
 
562
 
 
563
        This only applies to branches that use this repository.
 
564
 
 
565
        The default is 'True'.
 
566
        :param new_value: True to restore the default, False to disable making
 
567
                          working trees.
 
568
        """
 
569
        # FIXME: split out into a new class/strategy ?
 
570
        if isinstance(self._format, (RepositoryFormat4,
 
571
                                     RepositoryFormat5,
 
572
                                     RepositoryFormat6)):
 
573
            raise NotImplementedError(self.set_make_working_trees)
 
574
        if new_value:
 
575
            try:
 
576
                self.control_files._transport.delete('no-working-trees')
 
577
            except errors.NoSuchFile:
 
578
                pass
 
579
        else:
 
580
            self.control_files.put_utf8('no-working-trees', '')
 
581
    
 
582
    def make_working_trees(self):
 
583
        """Returns the policy for making working trees on new branches."""
 
584
        # FIXME: split out into a new class/strategy ?
 
585
        if isinstance(self._format, (RepositoryFormat4,
 
586
                                     RepositoryFormat5,
 
587
                                     RepositoryFormat6)):
 
588
            return True
 
589
        return not self.control_files._transport.has('no-working-trees')
 
590
 
 
591
    @needs_write_lock
 
592
    def sign_revision(self, revision_id, gpg_strategy):
 
593
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
 
594
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
 
595
 
 
596
    @needs_read_lock
 
597
    def has_signature_for_revision_id(self, revision_id):
 
598
        """Query for a revision signature for revision_id in the repository."""
 
599
        return self._revision_store.has_signature(revision_id,
 
600
                                                  self.get_transaction())
 
601
 
 
602
    @needs_read_lock
 
603
    def get_signature_text(self, revision_id):
 
604
        """Return the text for a signature."""
 
605
        return self._revision_store.get_signature_text(revision_id,
 
606
                                                       self.get_transaction())
 
607
 
 
608
 
 
609
class AllInOneRepository(Repository):
 
610
    """Legacy support - the repository behaviour for all-in-one branches."""
 
611
 
 
612
    def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
 
613
        # we reuse one control files instance.
 
614
        dir_mode = a_bzrdir._control_files._dir_mode
 
615
        file_mode = a_bzrdir._control_files._file_mode
 
616
 
 
617
        def get_weave(name, prefixed=False):
 
618
            if name:
 
619
                name = safe_unicode(name)
 
620
            else:
 
621
                name = ''
 
622
            relpath = a_bzrdir._control_files._escape(name)
 
623
            weave_transport = a_bzrdir._control_files._transport.clone(relpath)
 
624
            ws = WeaveStore(weave_transport, prefixed=prefixed,
 
625
                            dir_mode=dir_mode,
 
626
                            file_mode=file_mode)
 
627
            if a_bzrdir._control_files._transport.should_cache():
 
628
                ws.enable_cache = True
 
629
            return ws
 
630
 
 
631
        def get_store(name, compressed=True, prefixed=False):
 
632
            # FIXME: This approach of assuming stores are all entirely compressed
 
633
            # or entirely uncompressed is tidy, but breaks upgrade from 
 
634
            # some existing branches where there's a mixture; we probably 
 
635
            # still want the option to look for both.
 
636
            relpath = a_bzrdir._control_files._escape(name)
 
637
            store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
 
638
                              prefixed=prefixed, compressed=compressed,
 
639
                              dir_mode=dir_mode,
 
640
                              file_mode=file_mode)
 
641
            #if self._transport.should_cache():
 
642
            #    cache_path = os.path.join(self.cache_root, name)
 
643
            #    os.mkdir(cache_path)
 
644
            #    store = bzrlib.store.CachedStore(store, cache_path)
 
645
            return store
 
646
 
 
647
        # not broken out yet because the controlweaves|inventory_store
 
648
        # and text_store | weave_store bits are still different.
 
649
        if isinstance(_format, RepositoryFormat4):
 
650
            # cannot remove these - there is still no consistent api 
 
651
            # which allows access to this old info.
 
652
            self.inventory_store = get_store('inventory-store')
 
653
            text_store = get_store('text-store')
 
654
        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
 
655
 
 
656
 
 
657
class MetaDirRepository(Repository):
 
658
    """Repositories in the new meta-dir layout."""
 
659
 
 
660
    def __init__(self, _format, a_bzrdir, control_files, _revision_store, control_store, text_store):
 
661
        super(MetaDirRepository, self).__init__(_format,
 
662
                                                a_bzrdir,
 
663
                                                control_files,
 
664
                                                _revision_store,
 
665
                                                control_store,
 
666
                                                text_store)
 
667
 
 
668
        dir_mode = self.control_files._dir_mode
 
669
        file_mode = self.control_files._file_mode
 
670
 
 
671
        def get_weave(name, prefixed=False):
 
672
            if name:
 
673
                name = safe_unicode(name)
 
674
            else:
 
675
                name = ''
 
676
            relpath = self.control_files._escape(name)
 
677
            weave_transport = self.control_files._transport.clone(relpath)
 
678
            ws = WeaveStore(weave_transport, prefixed=prefixed,
 
679
                            dir_mode=dir_mode,
 
680
                            file_mode=file_mode)
 
681
            if self.control_files._transport.should_cache():
 
682
                ws.enable_cache = True
 
683
            return ws
 
684
 
 
685
 
 
686
class KnitRepository(MetaDirRepository):
 
687
    """Knit format repository."""
 
688
 
 
689
    @needs_read_lock
 
690
    def all_revision_ids(self):
 
691
        """See Repository.all_revision_ids()."""
 
692
        return self._revision_store.all_revision_ids(self.get_transaction())
 
693
 
 
694
    @needs_read_lock
 
695
    def get_ancestry(self, revision_id):
 
696
        """Return a list of revision-ids integrated by a revision.
 
697
        
 
698
        This is topologically sorted.
 
699
        """
 
700
        if revision_id is None:
 
701
            return [None]
 
702
        vf = self._revision_store.get_revision_file(self.get_transaction())
 
703
        try:
 
704
            return [None] + vf.get_ancestry(revision_id)
 
705
        except errors.RevisionNotPresent:
 
706
            raise errors.NoSuchRevision(self, revision_id)
 
707
 
 
708
    @needs_read_lock
 
709
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
710
        """Return a graph of the revisions with ghosts marked as applicable.
 
711
 
 
712
        :param revision_ids: an iterable of revisions to graph or None for all.
 
713
        :return: a Graph object with the graph reachable from revision_ids.
 
714
        """
 
715
        result = Graph()
 
716
        vf = self._revision_store.get_revision_file(self.get_transaction())
 
717
        versions = vf.versions()
 
718
        if not revision_ids:
 
719
            pending = set(self.all_revision_ids())
 
720
            required = set([])
 
721
        else:
 
722
            pending = set(revision_ids)
 
723
            required = set(revision_ids)
 
724
        done = set([])
 
725
        while len(pending):
 
726
            revision_id = pending.pop()
 
727
            if not revision_id in versions:
 
728
                if revision_id in required:
 
729
                    raise errors.NoSuchRevision(self, revision_id)
 
730
                # a ghost
 
731
                result.add_ghost(revision_id)
 
732
                continue
 
733
            parent_ids = vf.get_parents_with_ghosts(revision_id)
 
734
            for parent_id in parent_ids:
 
735
                # is this queued or done ?
 
736
                if (parent_id not in pending and
 
737
                    parent_id not in done):
 
738
                    # no, queue it.
 
739
                    pending.add(parent_id)
 
740
            result.add_node(revision_id, parent_ids)
 
741
            done.add(result)
 
742
        return result
 
743
 
 
744
    @needs_write_lock
 
745
    def reconcile(self):
 
746
        """Reconcile this repository."""
 
747
        from bzrlib.reconcile import KnitReconciler
 
748
        reconciler = KnitReconciler(self)
 
749
        reconciler.reconcile()
 
750
        return reconciler
 
751
    
 
752
 
 
753
class RepositoryFormat(object):
 
754
    """A repository format.
 
755
 
 
756
    Formats provide three things:
 
757
     * An initialization routine to construct repository data on disk.
 
758
     * a format string which is used when the BzrDir supports versioned
 
759
       children.
 
760
     * an open routine which returns a Repository instance.
 
761
 
 
762
    Formats are placed in an dict by their format string for reference 
 
763
    during opening. These should be subclasses of RepositoryFormat
 
764
    for consistency.
 
765
 
 
766
    Once a format is deprecated, just deprecate the initialize and open
 
767
    methods on the format class. Do not deprecate the object, as the 
 
768
    object will be created every system load.
 
769
 
 
770
    Common instance attributes:
 
771
    _matchingbzrdir - the bzrdir format that the repository format was
 
772
    originally written to work with. This can be used if manually
 
773
    constructing a bzrdir and repository, or more commonly for test suite
 
774
    parameterisation.
 
775
    """
 
776
 
 
777
    _default_format = None
 
778
    """The default format used for new repositories."""
 
779
 
 
780
    _formats = {}
 
781
    """The known formats."""
 
782
 
 
783
    @classmethod
 
784
    def find_format(klass, a_bzrdir):
 
785
        """Return the format for the repository object in a_bzrdir."""
 
786
        try:
 
787
            transport = a_bzrdir.get_repository_transport(None)
 
788
            format_string = transport.get("format").read()
 
789
            return klass._formats[format_string]
 
790
        except errors.NoSuchFile:
 
791
            raise errors.NoRepositoryPresent(a_bzrdir)
 
792
        except KeyError:
 
793
            raise errors.UnknownFormatError(format_string)
 
794
 
 
795
    def _get_control_store(self, repo_transport, control_files):
 
796
        """Return the control store for this repository."""
 
797
        raise NotImplementedError(self._get_control_store)
 
798
    
 
799
    @classmethod
 
800
    def get_default_format(klass):
 
801
        """Return the current default format."""
 
802
        return klass._default_format
 
803
 
 
804
    def get_format_string(self):
 
805
        """Return the ASCII format string that identifies this format.
 
806
        
 
807
        Note that in pre format ?? repositories the format string is 
 
808
        not permitted nor written to disk.
 
809
        """
 
810
        raise NotImplementedError(self.get_format_string)
 
811
 
 
812
    def _get_revision_store(self, repo_transport, control_files):
 
813
        """Return the revision store object for this a_bzrdir."""
 
814
        raise NotImplementedError(self._get_revision_store)
 
815
 
 
816
    def _get_text_rev_store(self,
 
817
                            transport,
 
818
                            control_files,
 
819
                            name,
 
820
                            compressed=True,
 
821
                            prefixed=False,
 
822
                            serializer=None):
 
823
        """Common logic for getting a revision store for a repository.
 
824
        
 
825
        see self._get_revision_store for the subclass-overridable method to 
 
826
        get the store for a repository.
 
827
        """
 
828
        from bzrlib.store.revision.text import TextRevisionStore
 
829
        dir_mode = control_files._dir_mode
 
830
        file_mode = control_files._file_mode
 
831
        text_store =TextStore(transport.clone(name),
 
832
                              prefixed=prefixed,
 
833
                              compressed=compressed,
 
834
                              dir_mode=dir_mode,
 
835
                              file_mode=file_mode)
 
836
        _revision_store = TextRevisionStore(text_store, serializer)
 
837
        return _revision_store
 
838
 
 
839
    def _get_versioned_file_store(self,
 
840
                                  name,
 
841
                                  transport,
 
842
                                  control_files,
 
843
                                  prefixed=True,
 
844
                                  versionedfile_class=WeaveFile):
 
845
        weave_transport = control_files._transport.clone(name)
 
846
        dir_mode = control_files._dir_mode
 
847
        file_mode = control_files._file_mode
 
848
        return VersionedFileStore(weave_transport, prefixed=prefixed,
 
849
                                dir_mode=dir_mode,
 
850
                                file_mode=file_mode,
 
851
                                versionedfile_class=versionedfile_class)
 
852
 
 
853
    def initialize(self, a_bzrdir, shared=False):
 
854
        """Initialize a repository of this format in a_bzrdir.
 
855
 
 
856
        :param a_bzrdir: The bzrdir to put the new repository in it.
 
857
        :param shared: The repository should be initialized as a sharable one.
 
858
 
 
859
        This may raise UninitializableFormat if shared repository are not
 
860
        compatible the a_bzrdir.
 
861
        """
 
862
 
 
863
    def is_supported(self):
 
864
        """Is this format supported?
 
865
 
 
866
        Supported formats must be initializable and openable.
 
867
        Unsupported formats may not support initialization or committing or 
 
868
        some other features depending on the reason for not being supported.
 
869
        """
 
870
        return True
 
871
 
 
872
    def open(self, a_bzrdir, _found=False):
 
873
        """Return an instance of this format for the bzrdir a_bzrdir.
 
874
        
 
875
        _found is a private parameter, do not use it.
 
876
        """
 
877
        raise NotImplementedError(self.open)
 
878
 
 
879
    @classmethod
 
880
    def register_format(klass, format):
 
881
        klass._formats[format.get_format_string()] = format
 
882
 
 
883
    @classmethod
 
884
    def set_default_format(klass, format):
 
885
        klass._default_format = format
 
886
 
 
887
    @classmethod
 
888
    def unregister_format(klass, format):
 
889
        assert klass._formats[format.get_format_string()] is format
 
890
        del klass._formats[format.get_format_string()]
 
891
 
 
892
 
 
893
class PreSplitOutRepositoryFormat(RepositoryFormat):
 
894
    """Base class for the pre split out repository formats."""
 
895
 
 
896
    def initialize(self, a_bzrdir, shared=False, _internal=False):
 
897
        """Create a weave repository.
 
898
        
 
899
        TODO: when creating split out bzr branch formats, move this to a common
 
900
        base for Format5, Format6. or something like that.
 
901
        """
 
902
        from bzrlib.weavefile import write_weave_v5
 
903
        from bzrlib.weave import Weave
 
904
 
 
905
        if shared:
 
906
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
 
907
 
 
908
        if not _internal:
 
909
            # always initialized when the bzrdir is.
 
910
            return self.open(a_bzrdir, _found=True)
 
911
        
 
912
        # Create an empty weave
 
913
        sio = StringIO()
 
914
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
 
915
        empty_weave = sio.getvalue()
 
916
 
 
917
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
918
        dirs = ['revision-store', 'weaves']
 
919
        files = [('inventory.weave', StringIO(empty_weave)),
 
920
                 ]
 
921
        
 
922
        # FIXME: RBC 20060125 dont peek under the covers
 
923
        # NB: no need to escape relative paths that are url safe.
 
924
        control_files = LockableFiles(a_bzrdir.transport, 'branch-lock',
 
925
                                      TransportLock)
 
926
        control_files.create_lock()
 
927
        control_files.lock_write()
 
928
        control_files._transport.mkdir_multi(dirs,
 
929
                mode=control_files._dir_mode)
 
930
        try:
 
931
            for file, content in files:
 
932
                control_files.put(file, content)
 
933
        finally:
 
934
            control_files.unlock()
 
935
        return self.open(a_bzrdir, _found=True)
 
936
 
 
937
    def _get_control_store(self, repo_transport, control_files):
 
938
        """Return the control store for this repository."""
 
939
        return self._get_versioned_file_store('',
 
940
                                              repo_transport,
 
941
                                              control_files,
 
942
                                              prefixed=False)
 
943
 
 
944
    def _get_text_store(self, transport, control_files):
 
945
        """Get a store for file texts for this format."""
 
946
        raise NotImplementedError(self._get_text_store)
 
947
 
 
948
    def open(self, a_bzrdir, _found=False):
 
949
        """See RepositoryFormat.open()."""
 
950
        if not _found:
 
951
            # we are being called directly and must probe.
 
952
            raise NotImplementedError
 
953
 
 
954
        repo_transport = a_bzrdir.get_repository_transport(None)
 
955
        control_files = a_bzrdir._control_files
 
956
        text_store = self._get_text_store(repo_transport, control_files)
 
957
        control_store = self._get_control_store(repo_transport, control_files)
 
958
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
959
        return AllInOneRepository(_format=self,
 
960
                                  a_bzrdir=a_bzrdir,
 
961
                                  _revision_store=_revision_store,
 
962
                                  control_store=control_store,
 
963
                                  text_store=text_store)
 
964
 
 
965
 
 
966
class RepositoryFormat4(PreSplitOutRepositoryFormat):
 
967
    """Bzr repository format 4.
 
968
 
 
969
    This repository format has:
 
970
     - flat stores
 
971
     - TextStores for texts, inventories,revisions.
 
972
 
 
973
    This format is deprecated: it indexes texts using a text id which is
 
974
    removed in format 5; initializationa and write support for this format
 
975
    has been removed.
 
976
    """
 
977
 
 
978
    def __init__(self):
 
979
        super(RepositoryFormat4, self).__init__()
 
980
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat4()
 
981
 
 
982
    def initialize(self, url, shared=False, _internal=False):
 
983
        """Format 4 branches cannot be created."""
 
984
        raise errors.UninitializableFormat(self)
 
985
 
 
986
    def is_supported(self):
 
987
        """Format 4 is not supported.
 
988
 
 
989
        It is not supported because the model changed from 4 to 5 and the
 
990
        conversion logic is expensive - so doing it on the fly was not 
 
991
        feasible.
 
992
        """
 
993
        return False
 
994
 
 
995
    def _get_control_store(self, repo_transport, control_files):
 
996
        """Format 4 repositories have no formal control store at this point.
 
997
        
 
998
        This will cause any control-file-needing apis to fail - this is desired.
 
999
        """
 
1000
        return None
 
1001
    
 
1002
    def _get_revision_store(self, repo_transport, control_files):
 
1003
        """See RepositoryFormat._get_revision_store()."""
 
1004
        from bzrlib.xml4 import serializer_v4
 
1005
        return self._get_text_rev_store(repo_transport,
 
1006
                                        control_files,
 
1007
                                        'revision-store',
 
1008
                                        serializer=serializer_v4)
 
1009
 
 
1010
    def _get_text_store(self, transport, control_files):
 
1011
        """See RepositoryFormat._get_text_store()."""
 
1012
 
 
1013
 
 
1014
class RepositoryFormat5(PreSplitOutRepositoryFormat):
 
1015
    """Bzr control format 5.
 
1016
 
 
1017
    This repository format has:
 
1018
     - weaves for file texts and inventory
 
1019
     - flat stores
 
1020
     - TextStores for revisions and signatures.
 
1021
    """
 
1022
 
 
1023
    def __init__(self):
 
1024
        super(RepositoryFormat5, self).__init__()
 
1025
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat5()
 
1026
 
 
1027
    def _get_revision_store(self, repo_transport, control_files):
 
1028
        """See RepositoryFormat._get_revision_store()."""
 
1029
        """Return the revision store object for this a_bzrdir."""
 
1030
        return self._get_text_rev_store(repo_transport,
 
1031
                                        control_files,
 
1032
                                        'revision-store',
 
1033
                                        compressed=False)
 
1034
 
 
1035
    def _get_text_store(self, transport, control_files):
 
1036
        """See RepositoryFormat._get_text_store()."""
 
1037
        return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
 
1038
 
 
1039
 
 
1040
class RepositoryFormat6(PreSplitOutRepositoryFormat):
 
1041
    """Bzr control format 6.
 
1042
 
 
1043
    This repository format has:
 
1044
     - weaves for file texts and inventory
 
1045
     - hash subdirectory based stores.
 
1046
     - TextStores for revisions and signatures.
 
1047
    """
 
1048
 
 
1049
    def __init__(self):
 
1050
        super(RepositoryFormat6, self).__init__()
 
1051
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat6()
 
1052
 
 
1053
    def _get_revision_store(self, repo_transport, control_files):
 
1054
        """See RepositoryFormat._get_revision_store()."""
 
1055
        return self._get_text_rev_store(repo_transport,
 
1056
                                        control_files,
 
1057
                                        'revision-store',
 
1058
                                        compressed=False,
 
1059
                                        prefixed=True)
 
1060
 
 
1061
    def _get_text_store(self, transport, control_files):
 
1062
        """See RepositoryFormat._get_text_store()."""
 
1063
        return self._get_versioned_file_store('weaves', transport, control_files)
 
1064
 
 
1065
 
 
1066
class MetaDirRepositoryFormat(RepositoryFormat):
 
1067
    """Common base class for the new repositories using the metadir layour."""
 
1068
 
 
1069
    def __init__(self):
 
1070
        super(MetaDirRepositoryFormat, self).__init__()
 
1071
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirMetaFormat1()
 
1072
 
 
1073
    def _create_control_files(self, a_bzrdir):
 
1074
        """Create the required files and the initial control_files object."""
 
1075
        # FIXME: RBC 20060125 dont peek under the covers
 
1076
        # NB: no need to escape relative paths that are url safe.
 
1077
        repository_transport = a_bzrdir.get_repository_transport(self)
 
1078
        control_files = LockableFiles(repository_transport, 'lock', LockDir)
 
1079
        control_files.create_lock()
 
1080
        return control_files
 
1081
 
 
1082
    def _upload_blank_content(self, a_bzrdir, dirs, files, utf8_files, shared):
 
1083
        """Upload the initial blank content."""
 
1084
        control_files = self._create_control_files(a_bzrdir)
 
1085
        control_files.lock_write()
 
1086
        try:
 
1087
            control_files._transport.mkdir_multi(dirs,
 
1088
                    mode=control_files._dir_mode)
 
1089
            for file, content in files:
 
1090
                control_files.put(file, content)
 
1091
            for file, content in utf8_files:
 
1092
                control_files.put_utf8(file, content)
 
1093
            if shared == True:
 
1094
                control_files.put_utf8('shared-storage', '')
 
1095
        finally:
 
1096
            control_files.unlock()
 
1097
 
 
1098
 
 
1099
class RepositoryFormat7(MetaDirRepositoryFormat):
 
1100
    """Bzr repository 7.
 
1101
 
 
1102
    This repository format has:
 
1103
     - weaves for file texts and inventory
 
1104
     - hash subdirectory based stores.
 
1105
     - TextStores for revisions and signatures.
 
1106
     - a format marker of its own
 
1107
     - an optional 'shared-storage' flag
 
1108
     - an optional 'no-working-trees' flag
 
1109
    """
 
1110
 
 
1111
    def _get_control_store(self, repo_transport, control_files):
 
1112
        """Return the control store for this repository."""
 
1113
        return self._get_versioned_file_store('',
 
1114
                                              repo_transport,
 
1115
                                              control_files,
 
1116
                                              prefixed=False)
 
1117
 
 
1118
    def get_format_string(self):
 
1119
        """See RepositoryFormat.get_format_string()."""
 
1120
        return "Bazaar-NG Repository format 7"
 
1121
 
 
1122
    def _get_revision_store(self, repo_transport, control_files):
 
1123
        """See RepositoryFormat._get_revision_store()."""
 
1124
        return self._get_text_rev_store(repo_transport,
 
1125
                                        control_files,
 
1126
                                        'revision-store',
 
1127
                                        compressed=False,
 
1128
                                        prefixed=True,
 
1129
                                        )
 
1130
 
 
1131
    def _get_text_store(self, transport, control_files):
 
1132
        """See RepositoryFormat._get_text_store()."""
 
1133
        return self._get_versioned_file_store('weaves',
 
1134
                                              transport,
 
1135
                                              control_files)
 
1136
 
 
1137
    def initialize(self, a_bzrdir, shared=False):
 
1138
        """Create a weave repository.
 
1139
 
 
1140
        :param shared: If true the repository will be initialized as a shared
 
1141
                       repository.
 
1142
        """
 
1143
        from bzrlib.weavefile import write_weave_v5
 
1144
        from bzrlib.weave import Weave
 
1145
 
 
1146
        # Create an empty weave
 
1147
        sio = StringIO()
 
1148
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
 
1149
        empty_weave = sio.getvalue()
 
1150
 
 
1151
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
1152
        dirs = ['revision-store', 'weaves']
 
1153
        files = [('inventory.weave', StringIO(empty_weave)), 
 
1154
                 ]
 
1155
        utf8_files = [('format', self.get_format_string())]
 
1156
 
 
1157
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
1158
        return self.open(a_bzrdir=a_bzrdir, _found=True)
 
1159
 
 
1160
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
1161
        """See RepositoryFormat.open().
 
1162
        
 
1163
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
1164
                                    repository at a slightly different url
 
1165
                                    than normal. I.e. during 'upgrade'.
 
1166
        """
 
1167
        if not _found:
 
1168
            format = RepositoryFormat.find_format(a_bzrdir)
 
1169
            assert format.__class__ ==  self.__class__
 
1170
        if _override_transport is not None:
 
1171
            repo_transport = _override_transport
 
1172
        else:
 
1173
            repo_transport = a_bzrdir.get_repository_transport(None)
 
1174
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
 
1175
        text_store = self._get_text_store(repo_transport, control_files)
 
1176
        control_store = self._get_control_store(repo_transport, control_files)
 
1177
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1178
        return MetaDirRepository(_format=self,
 
1179
                                 a_bzrdir=a_bzrdir,
 
1180
                                 control_files=control_files,
 
1181
                                 _revision_store=_revision_store,
 
1182
                                 control_store=control_store,
 
1183
                                 text_store=text_store)
 
1184
 
 
1185
 
 
1186
class RepositoryFormatKnit1(MetaDirRepositoryFormat):
 
1187
    """Bzr repository knit format 1.
 
1188
 
 
1189
    This repository format has:
 
1190
     - knits for file texts and inventory
 
1191
     - hash subdirectory based stores.
 
1192
     - knits for revisions and signatures
 
1193
     - TextStores for revisions and signatures.
 
1194
     - a format marker of its own
 
1195
     - an optional 'shared-storage' flag
 
1196
     - an optional 'no-working-trees' flag
 
1197
     - a LockDir lock
 
1198
    """
 
1199
 
 
1200
    def _get_control_store(self, repo_transport, control_files):
 
1201
        """Return the control store for this repository."""
 
1202
        return self._get_versioned_file_store('',
 
1203
                                              repo_transport,
 
1204
                                              control_files,
 
1205
                                              prefixed=False,
 
1206
                                              versionedfile_class=KnitVersionedFile)
 
1207
 
 
1208
    def get_format_string(self):
 
1209
        """See RepositoryFormat.get_format_string()."""
 
1210
        return "Bazaar-NG Knit Repository Format 1"
 
1211
 
 
1212
    def _get_revision_store(self, repo_transport, control_files):
 
1213
        """See RepositoryFormat._get_revision_store()."""
 
1214
        from bzrlib.store.revision.knit import KnitRevisionStore
 
1215
        versioned_file_store = VersionedFileStore(
 
1216
            repo_transport,
 
1217
            file_mode = control_files._file_mode,
 
1218
            prefixed=False,
 
1219
            precious=True,
 
1220
            versionedfile_class=KnitVersionedFile)
 
1221
        return KnitRevisionStore(versioned_file_store)
 
1222
 
 
1223
    def _get_text_store(self, transport, control_files):
 
1224
        """See RepositoryFormat._get_text_store()."""
 
1225
        return self._get_versioned_file_store('knits',
 
1226
                                              transport,
 
1227
                                              control_files,
 
1228
                                              versionedfile_class=KnitVersionedFile)
 
1229
 
 
1230
    def initialize(self, a_bzrdir, shared=False):
 
1231
        """Create a knit format 1 repository.
 
1232
 
 
1233
        :param shared: If true the repository will be initialized as a shared
 
1234
                       repository.
 
1235
        XXX NOTE that this current uses a Weave for testing and will become 
 
1236
            A Knit in due course.
 
1237
        """
 
1238
        from bzrlib.weavefile import write_weave_v5
 
1239
        from bzrlib.weave import Weave
 
1240
 
 
1241
        # Create an empty weave
 
1242
        sio = StringIO()
 
1243
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
 
1244
        empty_weave = sio.getvalue()
 
1245
 
 
1246
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
1247
        dirs = ['revision-store', 'knits', 'control']
 
1248
        files = [('control/inventory.weave', StringIO(empty_weave)), 
 
1249
                 ]
 
1250
        utf8_files = [('format', self.get_format_string())]
 
1251
        
 
1252
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
1253
        repo_transport = a_bzrdir.get_repository_transport(None)
 
1254
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
 
1255
        control_store = self._get_control_store(repo_transport, control_files)
 
1256
        transaction = bzrlib.transactions.PassThroughTransaction()
 
1257
        # trigger a write of the inventory store.
 
1258
        control_store.get_weave_or_empty('inventory', transaction)
 
1259
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1260
        _revision_store.has_revision_id('A', transaction)
 
1261
        _revision_store.get_signature_file(transaction)
 
1262
        return self.open(a_bzrdir=a_bzrdir, _found=True)
 
1263
 
 
1264
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
1265
        """See RepositoryFormat.open().
 
1266
        
 
1267
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
1268
                                    repository at a slightly different url
 
1269
                                    than normal. I.e. during 'upgrade'.
 
1270
        """
 
1271
        if not _found:
 
1272
            format = RepositoryFormat.find_format(a_bzrdir)
 
1273
            assert format.__class__ ==  self.__class__
 
1274
        if _override_transport is not None:
 
1275
            repo_transport = _override_transport
 
1276
        else:
 
1277
            repo_transport = a_bzrdir.get_repository_transport(None)
 
1278
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
 
1279
        text_store = self._get_text_store(repo_transport, control_files)
 
1280
        control_store = self._get_control_store(repo_transport, control_files)
 
1281
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1282
        return KnitRepository(_format=self,
 
1283
                              a_bzrdir=a_bzrdir,
 
1284
                              control_files=control_files,
 
1285
                              _revision_store=_revision_store,
 
1286
                              control_store=control_store,
 
1287
                              text_store=text_store)
 
1288
 
 
1289
 
 
1290
# formats which have no format string are not discoverable
 
1291
# and not independently creatable, so are not registered.
 
1292
_default_format = RepositoryFormat7()
 
1293
RepositoryFormat.register_format(_default_format)
 
1294
RepositoryFormat.register_format(RepositoryFormatKnit1())
 
1295
RepositoryFormat.set_default_format(_default_format)
 
1296
_legacy_formats = [RepositoryFormat4(),
 
1297
                   RepositoryFormat5(),
 
1298
                   RepositoryFormat6()]
 
1299
 
 
1300
 
 
1301
class InterRepository(InterObject):
 
1302
    """This class represents operations taking place between two repositories.
 
1303
 
 
1304
    Its instances have methods like copy_content and fetch, and contain
 
1305
    references to the source and target repositories these operations can be 
 
1306
    carried out on.
 
1307
 
 
1308
    Often we will provide convenience methods on 'repository' which carry out
 
1309
    operations with another repository - they will always forward to
 
1310
    InterRepository.get(other).method_name(parameters).
 
1311
    """
 
1312
 
 
1313
    _optimisers = set()
 
1314
    """The available optimised InterRepository types."""
 
1315
 
 
1316
    @needs_write_lock
 
1317
    def copy_content(self, revision_id=None, basis=None):
 
1318
        """Make a complete copy of the content in self into destination.
 
1319
        
 
1320
        This is a destructive operation! Do not use it on existing 
 
1321
        repositories.
 
1322
 
 
1323
        :param revision_id: Only copy the content needed to construct
 
1324
                            revision_id and its parents.
 
1325
        :param basis: Copy the needed data preferentially from basis.
 
1326
        """
 
1327
        try:
 
1328
            self.target.set_make_working_trees(self.source.make_working_trees())
 
1329
        except NotImplementedError:
 
1330
            pass
 
1331
        # grab the basis available data
 
1332
        if basis is not None:
 
1333
            self.target.fetch(basis, revision_id=revision_id)
 
1334
        # but dont bother fetching if we have the needed data now.
 
1335
        if (revision_id not in (None, NULL_REVISION) and 
 
1336
            self.target.has_revision(revision_id)):
 
1337
            return
 
1338
        self.target.fetch(self.source, revision_id=revision_id)
 
1339
 
 
1340
    def _double_lock(self, lock_source, lock_target):
 
1341
        """Take out too locks, rolling back the first if the second throws."""
 
1342
        lock_source()
 
1343
        try:
 
1344
            lock_target()
 
1345
        except Exception:
 
1346
            # we want to ensure that we don't leave source locked by mistake.
 
1347
            # and any error on target should not confuse source.
 
1348
            self.source.unlock()
 
1349
            raise
 
1350
 
 
1351
    @needs_write_lock
 
1352
    def fetch(self, revision_id=None, pb=None):
 
1353
        """Fetch the content required to construct revision_id.
 
1354
 
 
1355
        The content is copied from source to target.
 
1356
 
 
1357
        :param revision_id: if None all content is copied, if NULL_REVISION no
 
1358
                            content is copied.
 
1359
        :param pb: optional progress bar to use for progress reports. If not
 
1360
                   provided a default one will be created.
 
1361
 
 
1362
        Returns the copied revision count and the failed revisions in a tuple:
 
1363
        (copied, failures).
 
1364
        """
 
1365
        from bzrlib.fetch import GenericRepoFetcher
 
1366
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1367
               self.source, self.source._format, self.target, self.target._format)
 
1368
        f = GenericRepoFetcher(to_repository=self.target,
 
1369
                               from_repository=self.source,
 
1370
                               last_revision=revision_id,
 
1371
                               pb=pb)
 
1372
        return f.count_copied, f.failed_revisions
 
1373
 
 
1374
    def lock_read(self):
 
1375
        """Take out a logical read lock.
 
1376
 
 
1377
        This will lock the source branch and the target branch. The source gets
 
1378
        a read lock and the target a read lock.
 
1379
        """
 
1380
        self._double_lock(self.source.lock_read, self.target.lock_read)
 
1381
 
 
1382
    def lock_write(self):
 
1383
        """Take out a logical write lock.
 
1384
 
 
1385
        This will lock the source branch and the target branch. The source gets
 
1386
        a read lock and the target a write lock.
 
1387
        """
 
1388
        self._double_lock(self.source.lock_read, self.target.lock_write)
 
1389
 
 
1390
    @needs_read_lock
 
1391
    def missing_revision_ids(self, revision_id=None):
 
1392
        """Return the revision ids that source has that target does not.
 
1393
        
 
1394
        These are returned in topological order.
 
1395
 
 
1396
        :param revision_id: only return revision ids included by this
 
1397
                            revision_id.
 
1398
        """
 
1399
        # generic, possibly worst case, slow code path.
 
1400
        target_ids = set(self.target.all_revision_ids())
 
1401
        if revision_id is not None:
 
1402
            source_ids = self.source.get_ancestry(revision_id)
 
1403
            assert source_ids.pop(0) == None
 
1404
        else:
 
1405
            source_ids = self.source.all_revision_ids()
 
1406
        result_set = set(source_ids).difference(target_ids)
 
1407
        # this may look like a no-op: its not. It preserves the ordering
 
1408
        # other_ids had while only returning the members from other_ids
 
1409
        # that we've decided we need.
 
1410
        return [rev_id for rev_id in source_ids if rev_id in result_set]
 
1411
 
 
1412
    def unlock(self):
 
1413
        """Release the locks on source and target."""
 
1414
        try:
 
1415
            self.target.unlock()
 
1416
        finally:
 
1417
            self.source.unlock()
 
1418
 
 
1419
 
 
1420
class InterWeaveRepo(InterRepository):
 
1421
    """Optimised code paths between Weave based repositories."""
 
1422
 
 
1423
    _matching_repo_format = _default_format
 
1424
    """Repository format for testing with."""
 
1425
 
 
1426
    @staticmethod
 
1427
    def is_compatible(source, target):
 
1428
        """Be compatible with known Weave formats.
 
1429
        
 
1430
        We dont test for the stores being of specific types becase that
 
1431
        could lead to confusing results, and there is no need to be 
 
1432
        overly general.
 
1433
        """
 
1434
        try:
 
1435
            return (isinstance(source._format, (RepositoryFormat5,
 
1436
                                                RepositoryFormat6,
 
1437
                                                RepositoryFormat7)) and
 
1438
                    isinstance(target._format, (RepositoryFormat5,
 
1439
                                                RepositoryFormat6,
 
1440
                                                RepositoryFormat7)))
 
1441
        except AttributeError:
 
1442
            return False
 
1443
    
 
1444
    @needs_write_lock
 
1445
    def copy_content(self, revision_id=None, basis=None):
 
1446
        """See InterRepository.copy_content()."""
 
1447
        # weave specific optimised path:
 
1448
        if basis is not None:
 
1449
            # copy the basis in, then fetch remaining data.
 
1450
            basis.copy_content_into(self.target, revision_id)
 
1451
            # the basis copy_content_into could misset this.
 
1452
            try:
 
1453
                self.target.set_make_working_trees(self.source.make_working_trees())
 
1454
            except NotImplementedError:
 
1455
                pass
 
1456
            self.target.fetch(self.source, revision_id=revision_id)
 
1457
        else:
 
1458
            try:
 
1459
                self.target.set_make_working_trees(self.source.make_working_trees())
 
1460
            except NotImplementedError:
 
1461
                pass
 
1462
            # FIXME do not peek!
 
1463
            if self.source.control_files._transport.listable():
 
1464
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1465
                try:
 
1466
                    self.target.weave_store.copy_all_ids(
 
1467
                        self.source.weave_store,
 
1468
                        pb=pb,
 
1469
                        from_transaction=self.source.get_transaction(),
 
1470
                        to_transaction=self.target.get_transaction())
 
1471
                    pb.update('copying inventory', 0, 1)
 
1472
                    self.target.control_weaves.copy_multi(
 
1473
                        self.source.control_weaves, ['inventory'],
 
1474
                        from_transaction=self.source.get_transaction(),
 
1475
                        to_transaction=self.target.get_transaction())
 
1476
                    self.target._revision_store.text_store.copy_all_ids(
 
1477
                        self.source._revision_store.text_store,
 
1478
                        pb=pb)
 
1479
                finally:
 
1480
                    pb.finished()
 
1481
            else:
 
1482
                self.target.fetch(self.source, revision_id=revision_id)
 
1483
 
 
1484
    @needs_write_lock
 
1485
    def fetch(self, revision_id=None, pb=None):
 
1486
        """See InterRepository.fetch()."""
 
1487
        from bzrlib.fetch import GenericRepoFetcher
 
1488
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1489
               self.source, self.source._format, self.target, self.target._format)
 
1490
        f = GenericRepoFetcher(to_repository=self.target,
 
1491
                               from_repository=self.source,
 
1492
                               last_revision=revision_id,
 
1493
                               pb=pb)
 
1494
        return f.count_copied, f.failed_revisions
 
1495
 
 
1496
    @needs_read_lock
 
1497
    def missing_revision_ids(self, revision_id=None):
 
1498
        """See InterRepository.missing_revision_ids()."""
 
1499
        # we want all revisions to satisfy revision_id in source.
 
1500
        # but we dont want to stat every file here and there.
 
1501
        # we want then, all revisions other needs to satisfy revision_id 
 
1502
        # checked, but not those that we have locally.
 
1503
        # so the first thing is to get a subset of the revisions to 
 
1504
        # satisfy revision_id in source, and then eliminate those that
 
1505
        # we do already have. 
 
1506
        # this is slow on high latency connection to self, but as as this
 
1507
        # disk format scales terribly for push anyway due to rewriting 
 
1508
        # inventory.weave, this is considered acceptable.
 
1509
        # - RBC 20060209
 
1510
        if revision_id is not None:
 
1511
            source_ids = self.source.get_ancestry(revision_id)
 
1512
            assert source_ids.pop(0) == None
 
1513
        else:
 
1514
            source_ids = self.source._all_possible_ids()
 
1515
        source_ids_set = set(source_ids)
 
1516
        # source_ids is the worst possible case we may need to pull.
 
1517
        # now we want to filter source_ids against what we actually
 
1518
        # have in target, but dont try to check for existence where we know
 
1519
        # we do not have a revision as that would be pointless.
 
1520
        target_ids = set(self.target._all_possible_ids())
 
1521
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
1522
        actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
1523
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
1524
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
 
1525
        if revision_id is not None:
 
1526
            # we used get_ancestry to determine source_ids then we are assured all
 
1527
            # revisions referenced are present as they are installed in topological order.
 
1528
            # and the tip revision was validated by get_ancestry.
 
1529
            return required_topo_revisions
 
1530
        else:
 
1531
            # if we just grabbed the possibly available ids, then 
 
1532
            # we only have an estimate of whats available and need to validate
 
1533
            # that against the revision records.
 
1534
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
 
1535
 
 
1536
 
 
1537
class InterKnitRepo(InterRepository):
 
1538
    """Optimised code paths between Knit based repositories."""
 
1539
 
 
1540
    _matching_repo_format = RepositoryFormatKnit1()
 
1541
    """Repository format for testing with."""
 
1542
 
 
1543
    @staticmethod
 
1544
    def is_compatible(source, target):
 
1545
        """Be compatible with known Knit formats.
 
1546
        
 
1547
        We dont test for the stores being of specific types becase that
 
1548
        could lead to confusing results, and there is no need to be 
 
1549
        overly general.
 
1550
        """
 
1551
        try:
 
1552
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
 
1553
                    isinstance(target._format, (RepositoryFormatKnit1)))
 
1554
        except AttributeError:
 
1555
            return False
 
1556
 
 
1557
    @needs_write_lock
 
1558
    def fetch(self, revision_id=None, pb=None):
 
1559
        """See InterRepository.fetch()."""
 
1560
        from bzrlib.fetch import KnitRepoFetcher
 
1561
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1562
               self.source, self.source._format, self.target, self.target._format)
 
1563
        f = KnitRepoFetcher(to_repository=self.target,
 
1564
                            from_repository=self.source,
 
1565
                            last_revision=revision_id,
 
1566
                            pb=pb)
 
1567
        return f.count_copied, f.failed_revisions
 
1568
 
 
1569
    @needs_read_lock
 
1570
    def missing_revision_ids(self, revision_id=None):
 
1571
        """See InterRepository.missing_revision_ids()."""
 
1572
        if revision_id is not None:
 
1573
            source_ids = self.source.get_ancestry(revision_id)
 
1574
            assert source_ids.pop(0) == None
 
1575
        else:
 
1576
            source_ids = self.source._all_possible_ids()
 
1577
        source_ids_set = set(source_ids)
 
1578
        # source_ids is the worst possible case we may need to pull.
 
1579
        # now we want to filter source_ids against what we actually
 
1580
        # have in target, but dont try to check for existence where we know
 
1581
        # we do not have a revision as that would be pointless.
 
1582
        target_ids = set(self.target._all_possible_ids())
 
1583
        possibly_present_revisions = target_ids.intersection(source_ids_set)
 
1584
        actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
 
1585
        required_revisions = source_ids_set.difference(actually_present_revisions)
 
1586
        required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
 
1587
        if revision_id is not None:
 
1588
            # we used get_ancestry to determine source_ids then we are assured all
 
1589
            # revisions referenced are present as they are installed in topological order.
 
1590
            # and the tip revision was validated by get_ancestry.
 
1591
            return required_topo_revisions
 
1592
        else:
 
1593
            # if we just grabbed the possibly available ids, then 
 
1594
            # we only have an estimate of whats available and need to validate
 
1595
            # that against the revision records.
 
1596
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
 
1597
 
 
1598
InterRepository.register_optimiser(InterWeaveRepo)
 
1599
InterRepository.register_optimiser(InterKnitRepo)
 
1600
 
 
1601
 
 
1602
class RepositoryTestProviderAdapter(object):
 
1603
    """A tool to generate a suite testing multiple repository formats at once.
 
1604
 
 
1605
    This is done by copying the test once for each transport and injecting
 
1606
    the transport_server, transport_readonly_server, and bzrdir_format and
 
1607
    repository_format classes into each copy. Each copy is also given a new id()
 
1608
    to make it easy to identify.
 
1609
    """
 
1610
 
 
1611
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1612
        self._transport_server = transport_server
 
1613
        self._transport_readonly_server = transport_readonly_server
 
1614
        self._formats = formats
 
1615
    
 
1616
    def adapt(self, test):
 
1617
        result = TestSuite()
 
1618
        for repository_format, bzrdir_format in self._formats:
 
1619
            new_test = deepcopy(test)
 
1620
            new_test.transport_server = self._transport_server
 
1621
            new_test.transport_readonly_server = self._transport_readonly_server
 
1622
            new_test.bzrdir_format = bzrdir_format
 
1623
            new_test.repository_format = repository_format
 
1624
            def make_new_test_id():
 
1625
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
 
1626
                return lambda: new_id
 
1627
            new_test.id = make_new_test_id()
 
1628
            result.addTest(new_test)
 
1629
        return result
 
1630
 
 
1631
 
 
1632
class InterRepositoryTestProviderAdapter(object):
 
1633
    """A tool to generate a suite testing multiple inter repository formats.
 
1634
 
 
1635
    This is done by copying the test once for each interrepo provider and injecting
 
1636
    the transport_server, transport_readonly_server, repository_format and 
 
1637
    repository_to_format classes into each copy.
 
1638
    Each copy is also given a new id() to make it easy to identify.
 
1639
    """
 
1640
 
 
1641
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1642
        self._transport_server = transport_server
 
1643
        self._transport_readonly_server = transport_readonly_server
 
1644
        self._formats = formats
 
1645
    
 
1646
    def adapt(self, test):
 
1647
        result = TestSuite()
 
1648
        for interrepo_class, repository_format, repository_format_to in self._formats:
 
1649
            new_test = deepcopy(test)
 
1650
            new_test.transport_server = self._transport_server
 
1651
            new_test.transport_readonly_server = self._transport_readonly_server
 
1652
            new_test.interrepo_class = interrepo_class
 
1653
            new_test.repository_format = repository_format
 
1654
            new_test.repository_format_to = repository_format_to
 
1655
            def make_new_test_id():
 
1656
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
 
1657
                return lambda: new_id
 
1658
            new_test.id = make_new_test_id()
 
1659
            result.addTest(new_test)
 
1660
        return result
 
1661
 
 
1662
    @staticmethod
 
1663
    def default_test_list():
 
1664
        """Generate the default list of interrepo permutations to test."""
 
1665
        result = []
 
1666
        # test the default InterRepository between format 6 and the current 
 
1667
        # default format.
 
1668
        # XXX: robertc 20060220 reinstate this when there are two supported
 
1669
        # formats which do not have an optimal code path between them.
 
1670
        result.append((InterRepository,
 
1671
                       RepositoryFormat6(),
 
1672
                       RepositoryFormatKnit1()))
 
1673
        for optimiser in InterRepository._optimisers:
 
1674
            result.append((optimiser,
 
1675
                           optimiser._matching_repo_format,
 
1676
                           optimiser._matching_repo_format
 
1677
                           ))
 
1678
        # if there are specific combinations we want to use, we can add them 
 
1679
        # here.
 
1680
        return result
 
1681
 
 
1682
 
 
1683
class CopyConverter(object):
 
1684
    """A repository conversion tool which just performs a copy of the content.
 
1685
    
 
1686
    This is slow but quite reliable.
 
1687
    """
 
1688
 
 
1689
    def __init__(self, target_format):
 
1690
        """Create a CopyConverter.
 
1691
 
 
1692
        :param target_format: The format the resulting repository should be.
 
1693
        """
 
1694
        self.target_format = target_format
 
1695
        
 
1696
    def convert(self, repo, pb):
 
1697
        """Perform the conversion of to_convert, giving feedback via pb.
 
1698
 
 
1699
        :param to_convert: The disk object to convert.
 
1700
        :param pb: a progress bar to use for progress information.
 
1701
        """
 
1702
        self.pb = pb
 
1703
        self.count = 0
 
1704
        self.total = 3
 
1705
        # this is only useful with metadir layouts - separated repo content.
 
1706
        # trigger an assertion if not such
 
1707
        repo._format.get_format_string()
 
1708
        self.repo_dir = repo.bzrdir
 
1709
        self.step('Moving repository to repository.backup')
 
1710
        self.repo_dir.transport.move('repository', 'repository.backup')
 
1711
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
 
1712
        self.source_repo = repo._format.open(self.repo_dir,
 
1713
            _found=True,
 
1714
            _override_transport=backup_transport)
 
1715
        self.step('Creating new repository')
 
1716
        converted = self.target_format.initialize(self.repo_dir,
 
1717
                                                  self.source_repo.is_shared())
 
1718
        converted.lock_write()
 
1719
        try:
 
1720
            self.step('Copying content into repository.')
 
1721
            self.source_repo.copy_content_into(converted)
 
1722
        finally:
 
1723
            converted.unlock()
 
1724
        self.step('Deleting old repository content.')
 
1725
        self.repo_dir.transport.delete_tree('repository.backup')
 
1726
        self.pb.note('repository converted')
 
1727
 
 
1728
    def step(self, message):
 
1729
        """Update the pb by a step."""
 
1730
        self.count +=1
 
1731
        self.pb.update(message, self.count, self.total)