/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Robert Collins
  • Date: 2007-02-02 09:17:23 UTC
  • mfrom: (2249.4.2 tip.info)
  • mto: This revision was merged to the branch mainline in revision 2257.
  • Revision ID: robertc@robertcollins.net-20070202091723-xtak1zzhe2ylwksa
(robertc) Merge new Branch.last_revision_info method.

Show diffs side-by-side

added added

removed removed

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