← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Martin Pool
  • Date: 2006-06-05 18:00:36 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: mbp@sourcefrog.net-20060605180036-04f5d0cea94ed999
clean up test kipple

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