/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

Introduce a api specifically for looking at lines in some versions of the inventory, for fileid_involved.

Show diffs side-by-side

added added

removed removed

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