~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: mbp at sourcefrog
  • Date: 2005-04-09 07:04:27 UTC
  • Revision ID: mbp@sourcefrog.net-20050409070427-dfe3119cf1a0b290ea2f6ae2
Revfile: better __iter__ method that reads the whole index file in one go!

Show diffs side-by-side

added added

removed removed

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