~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-05-05 08:29:29 UTC
  • mfrom: (1697.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060505082929-a037ee137f1ff240
Merge break-lock command.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
 
17
from copy import deepcopy
17
18
from cStringIO import StringIO
18
 
 
19
 
from bzrlib.lazy_import import lazy_import
20
 
lazy_import(globals(), """
21
 
import re
22
 
import time
23
 
 
24
 
from bzrlib import (
25
 
    bzrdir,
26
 
    check,
27
 
    deprecated_graph,
28
 
    errors,
29
 
    generate_ids,
30
 
    gpg,
31
 
    graph,
32
 
    lazy_regex,
33
 
    lockable_files,
34
 
    lockdir,
35
 
    osutils,
36
 
    registry,
37
 
    remote,
38
 
    revision as _mod_revision,
39
 
    symbol_versioning,
40
 
    transactions,
41
 
    ui,
42
 
    )
43
 
from bzrlib.revisiontree import RevisionTree
44
 
from bzrlib.store.versioned import VersionedFileStore
 
19
from unittest import TestSuite
 
20
 
 
21
import bzrlib.bzrdir as bzrdir
 
22
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
23
import bzrlib.errors as errors
 
24
from bzrlib.errors import InvalidRevisionId
 
25
import bzrlib.gpg as gpg
 
26
from bzrlib.graph import Graph
 
27
from bzrlib.inter import InterObject
 
28
from bzrlib.knit import KnitVersionedFile, KnitPlainFactory
 
29
from bzrlib.lockable_files import LockableFiles, TransportLock
 
30
from bzrlib.lockdir import LockDir
 
31
from bzrlib.osutils import safe_unicode
 
32
from bzrlib.revision import NULL_REVISION
 
33
from bzrlib.store.versioned import VersionedFileStore, WeaveStore
45
34
from bzrlib.store.text import TextStore
 
35
from bzrlib.symbol_versioning import *
 
36
from bzrlib.trace import mutter, note
 
37
from bzrlib.tree import RevisionTree
 
38
from bzrlib.tsort import topo_sort
46
39
from bzrlib.testament import Testament
47
 
 
48
 
""")
49
 
 
50
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
51
 
from bzrlib.inter import InterObject
52
 
from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID
53
 
from bzrlib.symbol_versioning import (
54
 
        deprecated_method,
55
 
        zero_nine,
56
 
        )
57
 
from bzrlib.trace import mutter, note, warning
58
 
 
59
 
 
60
 
# Old formats display a warning, but only once
61
 
_deprecation_warning_done = False
62
 
 
63
 
 
64
 
######################################################################
65
 
# Repositories
 
40
from bzrlib.tree import EmptyTree
 
41
import bzrlib.ui
 
42
from bzrlib.weave import WeaveFile
 
43
import bzrlib.xml5
 
44
 
66
45
 
67
46
class Repository(object):
68
47
    """Repository holding history for one or more branches.
76
55
    remote) disk.
77
56
    """
78
57
 
79
 
    _file_ids_altered_regex = lazy_regex.lazy_compile(
80
 
        r'file_id="(?P<file_id>[^"]+)"'
81
 
        r'.*revision="(?P<revision_id>[^"]+)"'
82
 
        )
83
 
 
84
58
    @needs_write_lock
85
 
    def add_inventory(self, revision_id, inv, parents):
86
 
        """Add the inventory inv to the repository as revision_id.
 
59
    def add_inventory(self, revid, inv, parents):
 
60
        """Add the inventory inv to the repository as revid.
87
61
        
88
 
        :param parents: The revision ids of the parents that revision_id
 
62
        :param parents: The revision ids of the parents that revid
89
63
                        is known to have and are in the repository already.
90
64
 
91
65
        returns the sha1 of the serialized inventory.
92
66
        """
93
 
        revision_id = osutils.safe_revision_id(revision_id)
94
 
        _mod_revision.check_not_reserved_id(revision_id)
95
 
        assert inv.revision_id is None or inv.revision_id == revision_id, \
96
 
            "Mismatch between inventory revision" \
97
 
            " id and insertion revid (%r, %r)" % (inv.revision_id, revision_id)
98
 
        assert inv.root is not None
99
 
        inv_text = self.serialise_inventory(inv)
100
 
        inv_sha1 = osutils.sha_string(inv_text)
 
67
        inv_text = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
68
        inv_sha1 = bzrlib.osutils.sha_string(inv_text)
101
69
        inv_vf = self.control_weaves.get_weave('inventory',
102
70
                                               self.get_transaction())
103
 
        self._inventory_add_lines(inv_vf, revision_id, parents,
104
 
                                  osutils.split_lines(inv_text))
 
71
        inv_vf.add_lines(revid, parents, bzrlib.osutils.split_lines(inv_text))
105
72
        return inv_sha1
106
73
 
107
 
    def _inventory_add_lines(self, inv_vf, revision_id, parents, lines):
108
 
        final_parents = []
109
 
        for parent in parents:
110
 
            if parent in inv_vf:
111
 
                final_parents.append(parent)
112
 
 
113
 
        inv_vf.add_lines(revision_id, final_parents, lines)
114
 
 
115
74
    @needs_write_lock
116
 
    def add_revision(self, revision_id, rev, inv=None, config=None):
117
 
        """Add rev to the revision store as revision_id.
 
75
    def add_revision(self, rev_id, rev, inv=None, config=None):
 
76
        """Add rev to the revision store as rev_id.
118
77
 
119
 
        :param revision_id: the revision id to use.
 
78
        :param rev_id: the revision id to use.
120
79
        :param rev: The revision object.
121
80
        :param inv: The inventory for the revision. if None, it will be looked
122
81
                    up in the inventory storer
124
83
                       If supplied its signature_needed method will be used
125
84
                       to determine if a signature should be made.
126
85
        """
127
 
        revision_id = osutils.safe_revision_id(revision_id)
128
 
        # TODO: jam 20070210 Shouldn't we check rev.revision_id and
129
 
        #       rev.parent_ids?
130
 
        _mod_revision.check_not_reserved_id(revision_id)
131
86
        if config is not None and config.signature_needed():
132
87
            if inv is None:
133
 
                inv = self.get_inventory(revision_id)
 
88
                inv = self.get_inventory(rev_id)
134
89
            plaintext = Testament(rev, inv).as_short_text()
135
90
            self.store_revision_signature(
136
 
                gpg.GPGStrategy(config), plaintext, revision_id)
137
 
        if not revision_id in self.get_inventory_weave():
 
91
                gpg.GPGStrategy(config), plaintext, rev_id)
 
92
        if not rev_id in self.get_inventory_weave():
138
93
            if inv is None:
139
 
                raise errors.WeaveRevisionNotPresent(revision_id,
 
94
                raise errors.WeaveRevisionNotPresent(rev_id,
140
95
                                                     self.get_inventory_weave())
141
96
            else:
142
97
                # yes, this is not suitable for adding with ghosts.
143
 
                self.add_inventory(revision_id, inv, rev.parent_ids)
 
98
                self.add_inventory(rev_id, inv, rev.parent_ids)
144
99
        self._revision_store.add_revision(rev, self.get_transaction())
145
100
 
146
101
    @needs_read_lock
148
103
        """Return all the possible revisions that we could find."""
149
104
        return self.get_inventory_weave().versions()
150
105
 
 
106
    @needs_read_lock
151
107
    def all_revision_ids(self):
152
108
        """Returns a list of all the revision ids in the repository. 
153
109
 
154
 
        This is deprecated because code should generally work on the graph
155
 
        reachable from a particular revision, and ignore any other revisions
156
 
        that might be present.  There is no direct replacement method.
157
 
        """
158
 
        return self._all_revision_ids()
159
 
 
160
 
    @needs_read_lock
161
 
    def _all_revision_ids(self):
162
 
        """Returns a list of all the revision ids in the repository. 
163
 
 
164
110
        These are in as much topological order as the underlying store can 
165
111
        present: for weaves ghosts may lead to a lack of correctness until
166
112
        the reweave updates the parents list.
168
114
        if self._revision_store.text_store.listable():
169
115
            return self._revision_store.all_revision_ids(self.get_transaction())
170
116
        result = self._all_possible_ids()
171
 
        # TODO: jam 20070210 Ensure that _all_possible_ids returns non-unicode
172
 
        #       ids. (It should, since _revision_store's API should change to
173
 
        #       return utf8 revision_ids)
174
117
        return self._eliminate_revisions_not_present(result)
175
118
 
176
119
    def break_lock(self):
215
158
        self.control_files = control_files
216
159
        self._revision_store = _revision_store
217
160
        self.text_store = text_store
218
 
        # backwards compatibility
 
161
        # backwards compatability
219
162
        self.weave_store = text_store
220
163
        # not right yet - should be more semantically clear ? 
221
164
        # 
223
166
        self.control_weaves = control_store
224
167
        # TODO: make sure to construct the right store classes, etc, depending
225
168
        # on whether escaping is required.
226
 
        self._warn_if_deprecated()
227
 
 
228
 
    def __repr__(self):
229
 
        return '%s(%r)' % (self.__class__.__name__, 
230
 
                           self.bzrdir.transport.base)
231
169
 
232
170
    def is_locked(self):
233
171
        return self.control_files.is_locked()
234
172
 
235
 
    def lock_write(self, token=None):
236
 
        """Lock this repository for writing.
237
 
        
238
 
        :param token: if this is already locked, then lock_write will fail
239
 
            unless the token matches the existing lock.
240
 
        :returns: a token if this instance supports tokens, otherwise None.
241
 
        :raises TokenLockingNotSupported: when a token is given but this
242
 
            instance doesn't support using token locks.
243
 
        :raises MismatchedToken: if the specified token doesn't match the token
244
 
            of the existing lock.
245
 
 
246
 
        A token should be passed in if you know that you have locked the object
247
 
        some other way, and need to synchronise this object's state with that
248
 
        fact.
249
 
 
250
 
        XXX: this docstring is duplicated in many places, e.g. lockable_files.py
251
 
        """
252
 
        return self.control_files.lock_write(token=token)
 
173
    def lock_write(self):
 
174
        self.control_files.lock_write()
253
175
 
254
176
    def lock_read(self):
255
177
        self.control_files.lock_read()
257
179
    def get_physical_lock_status(self):
258
180
        return self.control_files.get_physical_lock_status()
259
181
 
260
 
    def leave_lock_in_place(self):
261
 
        """Tell this repository not to release the physical lock when this
262
 
        object is unlocked.
263
 
        
264
 
        If lock_write doesn't return a token, then this method is not supported.
265
 
        """
266
 
        self.control_files.leave_in_place()
267
 
 
268
 
    def dont_leave_lock_in_place(self):
269
 
        """Tell this repository to release the physical lock when this
270
 
        object is unlocked, even if it didn't originally acquire it.
271
 
 
272
 
        If lock_write doesn't return a token, then this method is not supported.
273
 
        """
274
 
        self.control_files.dont_leave_in_place()
275
 
 
276
 
    @needs_read_lock
277
 
    def gather_stats(self, revid=None, committers=None):
278
 
        """Gather statistics from a revision id.
279
 
 
280
 
        :param revid: The revision id to gather statistics from, if None, then
281
 
            no revision specific statistics are gathered.
282
 
        :param committers: Optional parameter controlling whether to grab
283
 
            a count of committers from the revision specific statistics.
284
 
        :return: A dictionary of statistics. Currently this contains:
285
 
            committers: The number of committers if requested.
286
 
            firstrev: A tuple with timestamp, timezone for the penultimate left
287
 
                most ancestor of revid, if revid is not the NULL_REVISION.
288
 
            latestrev: A tuple with timestamp, timezone for revid, if revid is
289
 
                not the NULL_REVISION.
290
 
            revisions: The total revision count in the repository.
291
 
            size: An estimate disk size of the repository in bytes.
292
 
        """
293
 
        result = {}
294
 
        if revid and committers:
295
 
            result['committers'] = 0
296
 
        if revid and revid != _mod_revision.NULL_REVISION:
297
 
            if committers:
298
 
                all_committers = set()
299
 
            revisions = self.get_ancestry(revid)
300
 
            # pop the leading None
301
 
            revisions.pop(0)
302
 
            first_revision = None
303
 
            if not committers:
304
 
                # ignore the revisions in the middle - just grab first and last
305
 
                revisions = revisions[0], revisions[-1]
306
 
            for revision in self.get_revisions(revisions):
307
 
                if not first_revision:
308
 
                    first_revision = revision
309
 
                if committers:
310
 
                    all_committers.add(revision.committer)
311
 
            last_revision = revision
312
 
            if committers:
313
 
                result['committers'] = len(all_committers)
314
 
            result['firstrev'] = (first_revision.timestamp,
315
 
                first_revision.timezone)
316
 
            result['latestrev'] = (last_revision.timestamp,
317
 
                last_revision.timezone)
318
 
 
319
 
        # now gather global repository information
320
 
        if self.bzrdir.root_transport.listable():
321
 
            c, t = self._revision_store.total_size(self.get_transaction())
322
 
            result['revisions'] = c
323
 
            result['size'] = t
324
 
        return result
325
 
 
326
182
    @needs_read_lock
327
183
    def missing_revision_ids(self, other, revision_id=None):
328
184
        """Return the revision ids that other has that this does not.
331
187
 
332
188
        revision_id: only return revision ids included by revision_id.
333
189
        """
334
 
        revision_id = osutils.safe_revision_id(revision_id)
335
190
        return InterRepository.get(other, self).missing_revision_ids(revision_id)
336
191
 
337
192
    @staticmethod
341
196
        For instance, if the repository is at URL/.bzr/repository,
342
197
        Repository.open(URL) -> a Repository instance.
343
198
        """
344
 
        control = bzrdir.BzrDir.open(base)
 
199
        control = bzrlib.bzrdir.BzrDir.open(base)
345
200
        return control.open_repository()
346
201
 
347
 
    def copy_content_into(self, destination, revision_id=None):
 
202
    def copy_content_into(self, destination, revision_id=None, basis=None):
348
203
        """Make a complete copy of the content in self into destination.
349
204
        
350
205
        This is a destructive operation! Do not use it on existing 
351
206
        repositories.
352
207
        """
353
 
        revision_id = osutils.safe_revision_id(revision_id)
354
 
        return InterRepository.get(self, destination).copy_content(revision_id)
 
208
        return InterRepository.get(self, destination).copy_content(revision_id, basis)
355
209
 
356
210
    def fetch(self, source, revision_id=None, pb=None):
357
211
        """Fetch the content required to construct revision_id from source.
358
212
 
359
213
        If revision_id is None all content is copied.
360
214
        """
361
 
        revision_id = osutils.safe_revision_id(revision_id)
362
 
        inter = InterRepository.get(source, self)
363
 
        try:
364
 
            return inter.fetch(revision_id=revision_id, pb=pb)
365
 
        except NotImplementedError:
366
 
            raise errors.IncompatibleRepositories(source, self)
367
 
 
368
 
    def get_commit_builder(self, branch, parents, config, timestamp=None, 
369
 
                           timezone=None, committer=None, revprops=None, 
370
 
                           revision_id=None):
371
 
        """Obtain a CommitBuilder for this repository.
372
 
        
373
 
        :param branch: Branch to commit to.
374
 
        :param parents: Revision ids of the parents of the new revision.
375
 
        :param config: Configuration to use.
376
 
        :param timestamp: Optional timestamp recorded for commit.
377
 
        :param timezone: Optional timezone for timestamp.
378
 
        :param committer: Optional committer to set for commit.
379
 
        :param revprops: Optional dictionary of revision properties.
380
 
        :param revision_id: Optional revision id.
381
 
        """
382
 
        revision_id = osutils.safe_revision_id(revision_id)
383
 
        return _CommitBuilder(self, parents, config, timestamp, timezone,
384
 
                              committer, revprops, revision_id)
 
215
        return InterRepository.get(source, self).fetch(revision_id=revision_id,
 
216
                                                       pb=pb)
385
217
 
386
218
    def unlock(self):
387
219
        self.control_files.unlock()
388
220
 
389
221
    @needs_read_lock
390
 
    def clone(self, a_bzrdir, revision_id=None):
 
222
    def clone(self, a_bzrdir, revision_id=None, basis=None):
391
223
        """Clone this repository into a_bzrdir using the current format.
392
224
 
393
225
        Currently no check is made that the format of this repository and
394
226
        the bzrdir format are compatible. FIXME RBC 20060201.
395
 
 
396
 
        :return: The newly created destination repository.
397
 
        """
398
 
        # TODO: deprecate after 0.16; cloning this with all its settings is
399
 
        # probably not very useful -- mbp 20070423
400
 
        dest_repo = self._create_sprouting_repo(a_bzrdir, shared=self.is_shared())
401
 
        self.copy_content_into(dest_repo, revision_id)
402
 
        return dest_repo
403
 
 
404
 
    @needs_read_lock
405
 
    def sprout(self, to_bzrdir, revision_id=None):
406
 
        """Create a descendent repository for new development.
407
 
 
408
 
        Unlike clone, this does not copy the settings of the repository.
409
 
        """
410
 
        dest_repo = self._create_sprouting_repo(to_bzrdir, shared=False)
411
 
        dest_repo.fetch(self, revision_id=revision_id)
412
 
        return dest_repo
413
 
 
414
 
    def _create_sprouting_repo(self, a_bzrdir, shared):
 
227
        """
415
228
        if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
416
229
            # use target default format.
417
 
            dest_repo = a_bzrdir.create_repository()
 
230
            result = a_bzrdir.create_repository()
 
231
        # FIXME RBC 20060209 split out the repository type to avoid this check ?
 
232
        elif isinstance(a_bzrdir._format,
 
233
                      (bzrlib.bzrdir.BzrDirFormat4,
 
234
                       bzrlib.bzrdir.BzrDirFormat5,
 
235
                       bzrlib.bzrdir.BzrDirFormat6)):
 
236
            result = a_bzrdir.open_repository()
418
237
        else:
419
 
            # Most control formats need the repository to be specifically
420
 
            # created, but on some old all-in-one formats it's not needed
421
 
            try:
422
 
                dest_repo = self._format.initialize(a_bzrdir, shared=shared)
423
 
            except errors.UninitializableFormat:
424
 
                dest_repo = a_bzrdir.open_repository()
425
 
        return dest_repo
 
238
            result = self._format.initialize(a_bzrdir, shared=self.is_shared())
 
239
        self.copy_content_into(result, revision_id, basis)
 
240
        return result
426
241
 
427
242
    @needs_read_lock
428
243
    def has_revision(self, revision_id):
429
244
        """True if this repository has a copy of the revision."""
430
 
        revision_id = osutils.safe_revision_id(revision_id)
431
245
        return self._revision_store.has_revision_id(revision_id,
432
246
                                                    self.get_transaction())
433
247
 
441
255
        or testing the revision graph.
442
256
        """
443
257
        if not revision_id or not isinstance(revision_id, basestring):
444
 
            raise errors.InvalidRevisionId(revision_id=revision_id,
445
 
                                           branch=self)
446
 
        return self.get_revisions([revision_id])[0]
447
 
 
448
 
    @needs_read_lock
449
 
    def get_revisions(self, revision_ids):
450
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
451
 
        revs = self._revision_store.get_revisions(revision_ids,
452
 
                                                  self.get_transaction())
453
 
        for rev in revs:
454
 
            assert not isinstance(rev.revision_id, unicode)
455
 
            for parent_id in rev.parent_ids:
456
 
                assert not isinstance(parent_id, unicode)
457
 
        return revs
 
258
            raise InvalidRevisionId(revision_id=revision_id, branch=self)
 
259
        return self._revision_store.get_revision(revision_id,
 
260
                                                 self.get_transaction())
458
261
 
459
262
    @needs_read_lock
460
263
    def get_revision_xml(self, revision_id):
461
 
        # TODO: jam 20070210 This shouldn't be necessary since get_revision
462
 
        #       would have already do it.
463
 
        # TODO: jam 20070210 Just use _serializer.write_revision_to_string()
464
 
        revision_id = osutils.safe_revision_id(revision_id)
465
 
        rev = self.get_revision(revision_id)
 
264
        rev = self.get_revision(revision_id) 
466
265
        rev_tmp = StringIO()
467
266
        # the current serializer..
468
267
        self._revision_store._serializer.write_revision(rev, rev_tmp)
472
271
    @needs_read_lock
473
272
    def get_revision(self, revision_id):
474
273
        """Return the Revision object for a named revision"""
475
 
        # TODO: jam 20070210 get_revision_reconcile should do this for us
476
 
        revision_id = osutils.safe_revision_id(revision_id)
477
274
        r = self.get_revision_reconcile(revision_id)
478
275
        # weave corruption can lead to absent revision markers that should be
479
276
        # present.
486
283
        self._check_revision_parents(r, inv)
487
284
        return r
488
285
 
489
 
    @needs_read_lock
490
 
    def get_deltas_for_revisions(self, revisions):
491
 
        """Produce a generator of revision deltas.
492
 
        
493
 
        Note that the input is a sequence of REVISIONS, not revision_ids.
494
 
        Trees will be held in memory until the generator exits.
495
 
        Each delta is relative to the revision's lefthand predecessor.
496
 
        """
497
 
        required_trees = set()
498
 
        for revision in revisions:
499
 
            required_trees.add(revision.revision_id)
500
 
            required_trees.update(revision.parent_ids[:1])
501
 
        trees = dict((t.get_revision_id(), t) for 
502
 
                     t in self.revision_trees(required_trees))
503
 
        for revision in revisions:
504
 
            if not revision.parent_ids:
505
 
                old_tree = self.revision_tree(None)
506
 
            else:
507
 
                old_tree = trees[revision.parent_ids[0]]
508
 
            yield trees[revision.revision_id].changes_from(old_tree)
509
 
 
510
 
    @needs_read_lock
511
 
    def get_revision_delta(self, revision_id):
512
 
        """Return the delta for one revision.
513
 
 
514
 
        The delta is relative to the left-hand predecessor of the
515
 
        revision.
516
 
        """
517
 
        r = self.get_revision(revision_id)
518
 
        return list(self.get_deltas_for_revisions([r]))[0]
519
 
 
520
286
    def _check_revision_parents(self, revision, inventory):
521
287
        """Private to Repository and Fetch.
522
288
        
535
301
 
536
302
    @needs_write_lock
537
303
    def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
538
 
        revision_id = osutils.safe_revision_id(revision_id)
539
304
        signature = gpg_strategy.sign(plaintext)
540
305
        self._revision_store.add_revision_signature_text(revision_id,
541
306
                                                         signature,
549
314
        revision_ids. Each altered file-ids has the exact revision_ids that
550
315
        altered it listed explicitly.
551
316
        """
552
 
        assert self._serializer.support_altered_by_hack, \
553
 
            ("fileids_altered_by_revision_ids only supported for branches " 
554
 
             "which store inventory as unnested xml, not on %r" % self)
555
 
        selected_revision_ids = set(osutils.safe_revision_id(r)
556
 
                                    for r in revision_ids)
 
317
        assert isinstance(self._format, (RepositoryFormat5,
 
318
                                         RepositoryFormat6,
 
319
                                         RepositoryFormat7,
 
320
                                         RepositoryFormatKnit1)), \
 
321
            "fileid_involved only supported for branches which store inventory as unnested xml"
 
322
        selected_revision_ids = set(revision_ids)
557
323
        w = self.get_inventory_weave()
558
324
        result = {}
559
325
 
560
326
        # this code needs to read every new line in every inventory for the
561
327
        # inventories [revision_ids]. Seeing a line twice is ok. Seeing a line
562
 
        # not present in one of those inventories is unnecessary but not 
 
328
        # not pesent in one of those inventories is unnecessary but not 
563
329
        # harmful because we are filtering by the revision id marker in the
564
330
        # inventory lines : we only select file ids altered in one of those  
565
 
        # revisions. We don't need to see all lines in the inventory because
 
331
        # revisions. We dont need to see all lines in the inventory because
566
332
        # only those added in an inventory in rev X can contain a revision=X
567
333
        # line.
568
 
        unescape_revid_cache = {}
569
 
        unescape_fileid_cache = {}
570
 
 
571
 
        # jam 20061218 In a big fetch, this handles hundreds of thousands
572
 
        # of lines, so it has had a lot of inlining and optimizing done.
573
 
        # Sorry that it is a little bit messy.
574
 
        # Move several functions to be local variables, since this is a long
575
 
        # running loop.
576
 
        search = self._file_ids_altered_regex.search
577
 
        unescape = _unescape_xml
578
 
        setdefault = result.setdefault
579
 
        pb = ui.ui_factory.nested_progress_bar()
580
 
        try:
581
 
            for line in w.iter_lines_added_or_present_in_versions(
582
 
                                        selected_revision_ids, pb=pb):
583
 
                match = search(line)
584
 
                if match is None:
585
 
                    continue
586
 
                # One call to match.group() returning multiple items is quite a
587
 
                # bit faster than 2 calls to match.group() each returning 1
588
 
                file_id, revision_id = match.group('file_id', 'revision_id')
589
 
 
590
 
                # Inlining the cache lookups helps a lot when you make 170,000
591
 
                # lines and 350k ids, versus 8.4 unique ids.
592
 
                # Using a cache helps in 2 ways:
593
 
                #   1) Avoids unnecessary decoding calls
594
 
                #   2) Re-uses cached strings, which helps in future set and
595
 
                #      equality checks.
596
 
                # (2) is enough that removing encoding entirely along with
597
 
                # the cache (so we are using plain strings) results in no
598
 
                # performance improvement.
599
 
                try:
600
 
                    revision_id = unescape_revid_cache[revision_id]
601
 
                except KeyError:
602
 
                    unescaped = unescape(revision_id)
603
 
                    unescape_revid_cache[revision_id] = unescaped
604
 
                    revision_id = unescaped
605
 
 
606
 
                if revision_id in selected_revision_ids:
607
 
                    try:
608
 
                        file_id = unescape_fileid_cache[file_id]
609
 
                    except KeyError:
610
 
                        unescaped = unescape(file_id)
611
 
                        unescape_fileid_cache[file_id] = unescaped
612
 
                        file_id = unescaped
613
 
                    setdefault(file_id, set()).add(revision_id)
614
 
        finally:
615
 
            pb.finished()
 
334
        for line in w.iter_lines_added_or_present_in_versions(selected_revision_ids):
 
335
            start = line.find('file_id="')+9
 
336
            if start < 9: continue
 
337
            end = line.find('"', start)
 
338
            assert end>= 0
 
339
            file_id = _unescape_xml(line[start:end])
 
340
 
 
341
            start = line.find('revision="')+10
 
342
            if start < 10: continue
 
343
            end = line.find('"', start)
 
344
            assert end>= 0
 
345
            revision_id = _unescape_xml(line[start:end])
 
346
            if revision_id in selected_revision_ids:
 
347
                result.setdefault(file_id, set()).add(revision_id)
616
348
        return result
617
349
 
618
350
    @needs_read_lock
623
355
    @needs_read_lock
624
356
    def get_inventory(self, revision_id):
625
357
        """Get Inventory object by hash."""
626
 
        # TODO: jam 20070210 Technically we don't need to sanitize, since all
627
 
        #       called functions must sanitize.
628
 
        revision_id = osutils.safe_revision_id(revision_id)
629
 
        return self.deserialise_inventory(
630
 
            revision_id, self.get_inventory_xml(revision_id))
631
 
 
632
 
    def deserialise_inventory(self, revision_id, xml):
633
 
        """Transform the xml into an inventory object. 
634
 
 
635
 
        :param revision_id: The expected revision id of the inventory.
636
 
        :param xml: A serialised inventory.
637
 
        """
638
 
        revision_id = osutils.safe_revision_id(revision_id)
639
 
        result = self._serializer.read_inventory_from_string(xml)
640
 
        result.root.revision = revision_id
641
 
        return result
642
 
 
643
 
    def serialise_inventory(self, inv):
644
 
        return self._serializer.write_inventory_to_string(inv)
 
358
        xml = self.get_inventory_xml(revision_id)
 
359
        return bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
645
360
 
646
361
    @needs_read_lock
647
362
    def get_inventory_xml(self, revision_id):
648
363
        """Get inventory XML as a file object."""
649
 
        revision_id = osutils.safe_revision_id(revision_id)
650
364
        try:
651
 
            assert isinstance(revision_id, str), type(revision_id)
 
365
            assert isinstance(revision_id, basestring), type(revision_id)
652
366
            iw = self.get_inventory_weave()
653
367
            return iw.get_text(revision_id)
654
368
        except IndexError:
655
 
            raise errors.HistoryMissing(self, 'inventory', revision_id)
 
369
            raise bzrlib.errors.HistoryMissing(self, 'inventory', revision_id)
656
370
 
657
371
    @needs_read_lock
658
372
    def get_inventory_sha1(self, revision_id):
659
373
        """Return the sha1 hash of the inventory entry
660
374
        """
661
 
        # TODO: jam 20070210 Shouldn't this be deprecated / removed?
662
 
        revision_id = osutils.safe_revision_id(revision_id)
663
375
        return self.get_revision(revision_id).inventory_sha1
664
376
 
665
377
    @needs_read_lock
666
378
    def get_revision_graph(self, revision_id=None):
667
379
        """Return a dictionary containing the revision graph.
668
380
        
669
 
        :param revision_id: The revision_id to get a graph from. If None, then
670
 
        the entire revision graph is returned. This is a deprecated mode of
671
 
        operation and will be removed in the future.
672
381
        :return: a dictionary of revision_id->revision_parents_list.
673
382
        """
674
 
        # special case NULL_REVISION
675
 
        if revision_id == _mod_revision.NULL_REVISION:
676
 
            return {}
677
 
        revision_id = osutils.safe_revision_id(revision_id)
678
 
        a_weave = self.get_inventory_weave()
679
 
        all_revisions = self._eliminate_revisions_not_present(
680
 
                                a_weave.versions())
681
 
        entire_graph = dict([(node, a_weave.get_parents(node)) for 
 
383
        weave = self.get_inventory_weave()
 
384
        all_revisions = self._eliminate_revisions_not_present(weave.versions())
 
385
        entire_graph = dict([(node, weave.get_parents(node)) for 
682
386
                             node in all_revisions])
683
387
        if revision_id is None:
684
388
            return entire_graph
703
407
        :param revision_ids: an iterable of revisions to graph or None for all.
704
408
        :return: a Graph object with the graph reachable from revision_ids.
705
409
        """
706
 
        result = deprecated_graph.Graph()
 
410
        result = Graph()
707
411
        if not revision_ids:
708
412
            pending = set(self.all_revision_ids())
709
413
            required = set([])
710
414
        else:
711
 
            pending = set(osutils.safe_revision_id(r) for r in revision_ids)
712
 
            # special case NULL_REVISION
713
 
            if _mod_revision.NULL_REVISION in pending:
714
 
                pending.remove(_mod_revision.NULL_REVISION)
715
 
            required = set(pending)
 
415
            pending = set(revision_ids)
 
416
            required = set(revision_ids)
716
417
        done = set([])
717
418
        while len(pending):
718
419
            revision_id = pending.pop()
734
435
            done.add(revision_id)
735
436
        return result
736
437
 
737
 
    def _get_history_vf(self):
738
 
        """Get a versionedfile whose history graph reflects all revisions.
739
 
 
740
 
        For weave repositories, this is the inventory weave.
741
 
        """
742
 
        return self.get_inventory_weave()
743
 
 
744
 
    def iter_reverse_revision_history(self, revision_id):
745
 
        """Iterate backwards through revision ids in the lefthand history
746
 
 
747
 
        :param revision_id: The revision id to start with.  All its lefthand
748
 
            ancestors will be traversed.
749
 
        """
750
 
        revision_id = osutils.safe_revision_id(revision_id)
751
 
        if revision_id in (None, _mod_revision.NULL_REVISION):
752
 
            return
753
 
        next_id = revision_id
754
 
        versionedfile = self._get_history_vf()
755
 
        while True:
756
 
            yield next_id
757
 
            parents = versionedfile.get_parents(next_id)
758
 
            if len(parents) == 0:
759
 
                return
760
 
            else:
761
 
                next_id = parents[0]
762
 
 
763
438
    @needs_read_lock
764
439
    def get_revision_inventory(self, revision_id):
765
440
        """Return inventory of a past revision."""
788
463
        reconciler = RepoReconciler(self, thorough=thorough)
789
464
        reconciler.reconcile()
790
465
        return reconciler
791
 
 
 
466
    
792
467
    @needs_read_lock
793
468
    def revision_tree(self, revision_id):
794
469
        """Return Tree for a revision on this branch.
795
470
 
796
 
        `revision_id` may be None for the empty tree revision.
797
 
        """
 
471
        `revision_id` may be None for the null revision, in which case
 
472
        an `EmptyTree` is returned."""
798
473
        # TODO: refactor this to use an existing revision object
799
474
        # so we don't need to read it in twice.
800
 
        if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
801
 
            return RevisionTree(self, Inventory(root_id=None), 
802
 
                                _mod_revision.NULL_REVISION)
 
475
        if revision_id is None or revision_id == NULL_REVISION:
 
476
            return EmptyTree()
803
477
        else:
804
 
            revision_id = osutils.safe_revision_id(revision_id)
805
478
            inv = self.get_revision_inventory(revision_id)
806
479
            return RevisionTree(self, inv, revision_id)
807
480
 
808
481
    @needs_read_lock
809
 
    def revision_trees(self, revision_ids):
810
 
        """Return Tree for a revision on this branch.
811
 
 
812
 
        `revision_id` may not be None or 'null:'"""
813
 
        assert None not in revision_ids
814
 
        assert _mod_revision.NULL_REVISION not in revision_ids
815
 
        texts = self.get_inventory_weave().get_texts(revision_ids)
816
 
        for text, revision_id in zip(texts, revision_ids):
817
 
            inv = self.deserialise_inventory(revision_id, text)
818
 
            yield RevisionTree(self, inv, revision_id)
819
 
 
820
 
    @needs_read_lock
821
 
    def get_ancestry(self, revision_id, topo_sorted=True):
 
482
    def get_ancestry(self, revision_id):
822
483
        """Return a list of revision-ids integrated by a revision.
823
 
 
824
 
        The first element of the list is always None, indicating the origin 
825
 
        revision.  This might change when we have history horizons, or 
826
 
        perhaps we should have a new API.
827
484
        
828
485
        This is topologically sorted.
829
486
        """
830
 
        if _mod_revision.is_null(revision_id):
 
487
        if revision_id is None:
831
488
            return [None]
832
 
        revision_id = osutils.safe_revision_id(revision_id)
833
489
        if not self.has_revision(revision_id):
834
490
            raise errors.NoSuchRevision(self, revision_id)
835
491
        w = self.get_inventory_weave()
836
 
        candidates = w.get_ancestry(revision_id, topo_sorted)
 
492
        candidates = w.get_ancestry(revision_id)
837
493
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
838
494
 
839
 
    def pack(self):
840
 
        """Compress the data within the repository.
841
 
 
842
 
        This operation only makes sense for some repository types. For other
843
 
        types it should be a no-op that just returns.
844
 
 
845
 
        This stub method does not require a lock, but subclasses should use
846
 
        @needs_write_lock as this is a long running call its reasonable to 
847
 
        implicitly lock for the user.
848
 
        """
849
 
 
850
495
    @needs_read_lock
851
496
    def print_file(self, file, revision_id):
852
497
        """Print `file` to stdout.
855
500
        - it writes to stdout, it assumes that that is valid etc. Fix
856
501
        by creating a new more flexible convenience function.
857
502
        """
858
 
        revision_id = osutils.safe_revision_id(revision_id)
859
503
        tree = self.revision_tree(revision_id)
860
504
        # use inventory as it was in that revision
861
505
        file_id = tree.inventory.path2id(file)
862
506
        if not file_id:
863
 
            # TODO: jam 20060427 Write a test for this code path
864
 
            #       it had a bug in it, and was raising the wrong
865
 
            #       exception.
866
 
            raise errors.BzrError("%r is not present in revision %s" % (file, revision_id))
 
507
            raise BzrError("%r is not present in revision %s" % (file, revno))
 
508
            try:
 
509
                revno = self.revision_id_to_revno(revision_id)
 
510
            except errors.NoSuchRevision:
 
511
                # TODO: This should not be BzrError,
 
512
                # but NoSuchFile doesn't fit either
 
513
                raise BzrError('%r is not present in revision %s' 
 
514
                                % (file, revision_id))
 
515
            else:
 
516
                raise BzrError('%r is not present in revision %s'
 
517
                                % (file, revno))
867
518
        tree.print_file(file_id)
868
519
 
869
520
    def get_transaction(self):
870
521
        return self.control_files.get_transaction()
871
522
 
872
 
    def revision_parents(self, revision_id):
873
 
        revision_id = osutils.safe_revision_id(revision_id)
874
 
        return self.get_inventory_weave().parent_names(revision_id)
875
 
 
876
 
    def get_parents(self, revision_ids):
877
 
        """See StackedParentsProvider.get_parents"""
878
 
        parents_list = []
879
 
        for revision_id in revision_ids:
880
 
            if revision_id == _mod_revision.NULL_REVISION:
881
 
                parents = []
882
 
            else:
883
 
                try:
884
 
                    parents = self.get_revision(revision_id).parent_ids
885
 
                except errors.NoSuchRevision:
886
 
                    parents = None
887
 
                else:
888
 
                    if len(parents) == 0:
889
 
                        parents = [_mod_revision.NULL_REVISION]
890
 
            parents_list.append(parents)
891
 
        return parents_list
892
 
 
893
 
    def _make_parents_provider(self):
894
 
        return self
895
 
 
896
 
    def get_graph(self, other_repository=None):
897
 
        """Return the graph walker for this repository format"""
898
 
        parents_provider = self._make_parents_provider()
899
 
        if (other_repository is not None and
900
 
            other_repository.bzrdir.transport.base !=
901
 
            self.bzrdir.transport.base):
902
 
            parents_provider = graph._StackedParentsProvider(
903
 
                [parents_provider, other_repository._make_parents_provider()])
904
 
        return graph.Graph(parents_provider)
 
523
    def revision_parents(self, revid):
 
524
        return self.get_inventory_weave().parent_names(revid)
905
525
 
906
526
    @needs_write_lock
907
527
    def set_make_working_trees(self, new_value):
921
541
 
922
542
    @needs_write_lock
923
543
    def sign_revision(self, revision_id, gpg_strategy):
924
 
        revision_id = osutils.safe_revision_id(revision_id)
925
544
        plaintext = Testament.from_revision(self, revision_id).as_short_text()
926
545
        self.store_revision_signature(gpg_strategy, plaintext, revision_id)
927
546
 
928
547
    @needs_read_lock
929
548
    def has_signature_for_revision_id(self, revision_id):
930
549
        """Query for a revision signature for revision_id in the repository."""
931
 
        revision_id = osutils.safe_revision_id(revision_id)
932
550
        return self._revision_store.has_signature(revision_id,
933
551
                                                  self.get_transaction())
934
552
 
935
553
    @needs_read_lock
936
554
    def get_signature_text(self, revision_id):
937
555
        """Return the text for a signature."""
938
 
        revision_id = osutils.safe_revision_id(revision_id)
939
556
        return self._revision_store.get_signature_text(revision_id,
940
557
                                                       self.get_transaction())
941
558
 
 
559
 
 
560
class AllInOneRepository(Repository):
 
561
    """Legacy support - the repository behaviour for all-in-one branches."""
 
562
 
 
563
    def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
 
564
        # we reuse one control files instance.
 
565
        dir_mode = a_bzrdir._control_files._dir_mode
 
566
        file_mode = a_bzrdir._control_files._file_mode
 
567
 
 
568
        def get_store(name, compressed=True, prefixed=False):
 
569
            # FIXME: This approach of assuming stores are all entirely compressed
 
570
            # or entirely uncompressed is tidy, but breaks upgrade from 
 
571
            # some existing branches where there's a mixture; we probably 
 
572
            # still want the option to look for both.
 
573
            relpath = a_bzrdir._control_files._escape(name)
 
574
            store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
 
575
                              prefixed=prefixed, compressed=compressed,
 
576
                              dir_mode=dir_mode,
 
577
                              file_mode=file_mode)
 
578
            #if self._transport.should_cache():
 
579
            #    cache_path = os.path.join(self.cache_root, name)
 
580
            #    os.mkdir(cache_path)
 
581
            #    store = bzrlib.store.CachedStore(store, cache_path)
 
582
            return store
 
583
 
 
584
        # not broken out yet because the controlweaves|inventory_store
 
585
        # and text_store | weave_store bits are still different.
 
586
        if isinstance(_format, RepositoryFormat4):
 
587
            # cannot remove these - there is still no consistent api 
 
588
            # which allows access to this old info.
 
589
            self.inventory_store = get_store('inventory-store')
 
590
            text_store = get_store('text-store')
 
591
        super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
 
592
 
942
593
    @needs_read_lock
943
 
    def check(self, revision_ids):
944
 
        """Check consistency of all history of given revision_ids.
945
 
 
946
 
        Different repository implementations should override _check().
947
 
 
948
 
        :param revision_ids: A non-empty list of revision_ids whose ancestry
949
 
             will be checked.  Typically the last revision_id of a branch.
 
594
    def is_shared(self):
 
595
        """AllInOne repositories cannot be shared."""
 
596
        return False
 
597
 
 
598
    @needs_write_lock
 
599
    def set_make_working_trees(self, new_value):
 
600
        """Set the policy flag for making working trees when creating branches.
 
601
 
 
602
        This only applies to branches that use this repository.
 
603
 
 
604
        The default is 'True'.
 
605
        :param new_value: True to restore the default, False to disable making
 
606
                          working trees.
950
607
        """
951
 
        if not revision_ids:
952
 
            raise ValueError("revision_ids must be non-empty in %s.check" 
953
 
                    % (self,))
954
 
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
955
 
        return self._check(revision_ids)
956
 
 
957
 
    def _check(self, revision_ids):
958
 
        result = check.Check(self)
959
 
        result.check()
960
 
        return result
961
 
 
962
 
    def _warn_if_deprecated(self):
963
 
        global _deprecation_warning_done
964
 
        if _deprecation_warning_done:
965
 
            return
966
 
        _deprecation_warning_done = True
967
 
        warning("Format %s for %s is deprecated - please use 'bzr upgrade' to get better performance"
968
 
                % (self._format, self.bzrdir.transport.base))
969
 
 
970
 
    def supports_rich_root(self):
971
 
        return self._format.rich_root_data
972
 
 
973
 
    def _check_ascii_revisionid(self, revision_id, method):
974
 
        """Private helper for ascii-only repositories."""
975
 
        # weave repositories refuse to store revisionids that are non-ascii.
976
 
        if revision_id is not None:
977
 
            # weaves require ascii revision ids.
978
 
            if isinstance(revision_id, unicode):
979
 
                try:
980
 
                    revision_id.encode('ascii')
981
 
                except UnicodeEncodeError:
982
 
                    raise errors.NonAsciiRevisionId(method, self)
983
 
            else:
984
 
                try:
985
 
                    revision_id.decode('ascii')
986
 
                except UnicodeDecodeError:
987
 
                    raise errors.NonAsciiRevisionId(method, self)
988
 
 
989
 
 
990
 
 
991
 
# remove these delegates a while after bzr 0.15
992
 
def __make_delegated(name, from_module):
993
 
    def _deprecated_repository_forwarder():
994
 
        symbol_versioning.warn('%s moved to %s in bzr 0.15'
995
 
            % (name, from_module),
996
 
            DeprecationWarning,
997
 
            stacklevel=2)
998
 
        m = __import__(from_module, globals(), locals(), [name])
999
 
        try:
1000
 
            return getattr(m, name)
1001
 
        except AttributeError:
1002
 
            raise AttributeError('module %s has no name %s'
1003
 
                    % (m, name))
1004
 
    globals()[name] = _deprecated_repository_forwarder
1005
 
 
1006
 
for _name in [
1007
 
        'AllInOneRepository',
1008
 
        'WeaveMetaDirRepository',
1009
 
        'PreSplitOutRepositoryFormat',
1010
 
        'RepositoryFormat4',
1011
 
        'RepositoryFormat5',
1012
 
        'RepositoryFormat6',
1013
 
        'RepositoryFormat7',
1014
 
        ]:
1015
 
    __make_delegated(_name, 'bzrlib.repofmt.weaverepo')
1016
 
 
1017
 
for _name in [
1018
 
        'KnitRepository',
1019
 
        'RepositoryFormatKnit',
1020
 
        'RepositoryFormatKnit1',
1021
 
        ]:
1022
 
    __make_delegated(_name, 'bzrlib.repofmt.knitrepo')
1023
 
 
1024
 
 
1025
 
def install_revision(repository, rev, revision_tree):
1026
 
    """Install all revision data into a repository."""
1027
 
    present_parents = []
1028
 
    parent_trees = {}
1029
 
    for p_id in rev.parent_ids:
1030
 
        if repository.has_revision(p_id):
1031
 
            present_parents.append(p_id)
1032
 
            parent_trees[p_id] = repository.revision_tree(p_id)
1033
 
        else:
1034
 
            parent_trees[p_id] = repository.revision_tree(None)
1035
 
 
1036
 
    inv = revision_tree.inventory
1037
 
    entries = inv.iter_entries()
1038
 
    # backwards compatability hack: skip the root id.
1039
 
    if not repository.supports_rich_root():
1040
 
        path, root = entries.next()
1041
 
        if root.revision != rev.revision_id:
1042
 
            raise errors.IncompatibleRevision(repr(repository))
1043
 
    # Add the texts that are not already present
1044
 
    for path, ie in entries:
1045
 
        w = repository.weave_store.get_weave_or_empty(ie.file_id,
1046
 
                repository.get_transaction())
1047
 
        if ie.revision not in w:
1048
 
            text_parents = []
1049
 
            # FIXME: TODO: The following loop *may* be overlapping/duplicate
1050
 
            # with InventoryEntry.find_previous_heads(). if it is, then there
1051
 
            # is a latent bug here where the parents may have ancestors of each
1052
 
            # other. RBC, AB
1053
 
            for revision, tree in parent_trees.iteritems():
1054
 
                if ie.file_id not in tree:
1055
 
                    continue
1056
 
                parent_id = tree.inventory[ie.file_id].revision
1057
 
                if parent_id in text_parents:
1058
 
                    continue
1059
 
                text_parents.append(parent_id)
1060
 
                    
1061
 
            vfile = repository.weave_store.get_weave_or_empty(ie.file_id, 
1062
 
                repository.get_transaction())
1063
 
            lines = revision_tree.get_file(ie.file_id).readlines()
1064
 
            vfile.add_lines(rev.revision_id, text_parents, lines)
1065
 
    try:
1066
 
        # install the inventory
1067
 
        repository.add_inventory(rev.revision_id, inv, present_parents)
1068
 
    except errors.RevisionAlreadyPresent:
1069
 
        pass
1070
 
    repository.add_revision(rev.revision_id, rev, inv)
 
608
        raise NotImplementedError(self.set_make_working_trees)
 
609
    
 
610
    def make_working_trees(self):
 
611
        """Returns the policy for making working trees on new branches."""
 
612
        return True
1071
613
 
1072
614
 
1073
615
class MetaDirRepository(Repository):
1080
622
                                                _revision_store,
1081
623
                                                control_store,
1082
624
                                                text_store)
 
625
 
1083
626
        dir_mode = self.control_files._dir_mode
1084
627
        file_mode = self.control_files._file_mode
1085
628
 
1111
654
        return not self.control_files._transport.has('no-working-trees')
1112
655
 
1113
656
 
1114
 
class RepositoryFormatRegistry(registry.Registry):
1115
 
    """Registry of RepositoryFormats.
1116
 
    """
1117
 
 
1118
 
    def get(self, format_string):
1119
 
        r = registry.Registry.get(self, format_string)
1120
 
        if callable(r):
1121
 
            r = r()
1122
 
        return r
 
657
class KnitRepository(MetaDirRepository):
 
658
    """Knit format repository."""
 
659
 
 
660
    @needs_read_lock
 
661
    def all_revision_ids(self):
 
662
        """See Repository.all_revision_ids()."""
 
663
        return self._revision_store.all_revision_ids(self.get_transaction())
 
664
 
 
665
    def fileid_involved_between_revs(self, from_revid, to_revid):
 
666
        """Find file_id(s) which are involved in the changes between revisions.
 
667
 
 
668
        This determines the set of revisions which are involved, and then
 
669
        finds all file ids affected by those revisions.
 
670
        """
 
671
        vf = self._get_revision_vf()
 
672
        from_set = set(vf.get_ancestry(from_revid))
 
673
        to_set = set(vf.get_ancestry(to_revid))
 
674
        changed = to_set.difference(from_set)
 
675
        return self._fileid_involved_by_set(changed)
 
676
 
 
677
    def fileid_involved(self, last_revid=None):
 
678
        """Find all file_ids modified in the ancestry of last_revid.
 
679
 
 
680
        :param last_revid: If None, last_revision() will be used.
 
681
        """
 
682
        if not last_revid:
 
683
            changed = set(self.all_revision_ids())
 
684
        else:
 
685
            changed = set(self.get_ancestry(last_revid))
 
686
        if None in changed:
 
687
            changed.remove(None)
 
688
        return self._fileid_involved_by_set(changed)
 
689
 
 
690
    @needs_read_lock
 
691
    def get_ancestry(self, revision_id):
 
692
        """Return a list of revision-ids integrated by a revision.
 
693
        
 
694
        This is topologically sorted.
 
695
        """
 
696
        if revision_id is None:
 
697
            return [None]
 
698
        vf = self._get_revision_vf()
 
699
        try:
 
700
            return [None] + vf.get_ancestry(revision_id)
 
701
        except errors.RevisionNotPresent:
 
702
            raise errors.NoSuchRevision(self, revision_id)
 
703
 
 
704
    @needs_read_lock
 
705
    def get_revision(self, revision_id):
 
706
        """Return the Revision object for a named revision"""
 
707
        return self.get_revision_reconcile(revision_id)
 
708
 
 
709
    @needs_read_lock
 
710
    def get_revision_graph(self, revision_id=None):
 
711
        """Return a dictionary containing the revision graph.
 
712
        
 
713
        :return: a dictionary of revision_id->revision_parents_list.
 
714
        """
 
715
        weave = self._get_revision_vf()
 
716
        entire_graph = weave.get_graph()
 
717
        if revision_id is None:
 
718
            return weave.get_graph()
 
719
        elif revision_id not in weave:
 
720
            raise errors.NoSuchRevision(self, revision_id)
 
721
        else:
 
722
            # add what can be reached from revision_id
 
723
            result = {}
 
724
            pending = set([revision_id])
 
725
            while len(pending) > 0:
 
726
                node = pending.pop()
 
727
                result[node] = weave.get_parents(node)
 
728
                for revision_id in result[node]:
 
729
                    if revision_id not in result:
 
730
                        pending.add(revision_id)
 
731
            return result
 
732
 
 
733
    @needs_read_lock
 
734
    def get_revision_graph_with_ghosts(self, revision_ids=None):
 
735
        """Return a graph of the revisions with ghosts marked as applicable.
 
736
 
 
737
        :param revision_ids: an iterable of revisions to graph or None for all.
 
738
        :return: a Graph object with the graph reachable from revision_ids.
 
739
        """
 
740
        result = Graph()
 
741
        vf = self._get_revision_vf()
 
742
        versions = set(vf.versions())
 
743
        if not revision_ids:
 
744
            pending = set(self.all_revision_ids())
 
745
            required = set([])
 
746
        else:
 
747
            pending = set(revision_ids)
 
748
            required = set(revision_ids)
 
749
        done = set([])
 
750
        while len(pending):
 
751
            revision_id = pending.pop()
 
752
            if not revision_id in versions:
 
753
                if revision_id in required:
 
754
                    raise errors.NoSuchRevision(self, revision_id)
 
755
                # a ghost
 
756
                result.add_ghost(revision_id)
 
757
                # mark it as done so we dont try for it again.
 
758
                done.add(revision_id)
 
759
                continue
 
760
            parent_ids = vf.get_parents_with_ghosts(revision_id)
 
761
            for parent_id in parent_ids:
 
762
                # is this queued or done ?
 
763
                if (parent_id not in pending and
 
764
                    parent_id not in done):
 
765
                    # no, queue it.
 
766
                    pending.add(parent_id)
 
767
            result.add_node(revision_id, parent_ids)
 
768
            done.add(revision_id)
 
769
        return result
 
770
 
 
771
    def _get_revision_vf(self):
 
772
        """:return: a versioned file containing the revisions."""
 
773
        vf = self._revision_store.get_revision_file(self.get_transaction())
 
774
        return vf
 
775
 
 
776
    @needs_write_lock
 
777
    def reconcile(self, other=None, thorough=False):
 
778
        """Reconcile this repository."""
 
779
        from bzrlib.reconcile import KnitReconciler
 
780
        reconciler = KnitReconciler(self, thorough=thorough)
 
781
        reconciler.reconcile()
 
782
        return reconciler
1123
783
    
1124
 
 
1125
 
format_registry = RepositoryFormatRegistry()
1126
 
"""Registry of formats, indexed by their identifying format string.
1127
 
 
1128
 
This can contain either format instances themselves, or classes/factories that
1129
 
can be called to obtain one.
1130
 
"""
1131
 
 
1132
 
 
1133
 
#####################################################################
1134
 
# Repository Formats
 
784
    def revision_parents(self, revid):
 
785
        return self._get_revision_vf().get_parents(rev_id)
1135
786
 
1136
787
class RepositoryFormat(object):
1137
788
    """A repository format.
1157
808
    parameterisation.
1158
809
    """
1159
810
 
1160
 
    def __str__(self):
1161
 
        return "<%s>" % self.__class__.__name__
1162
 
 
1163
 
    def __eq__(self, other):
1164
 
        # format objects are generally stateless
1165
 
        return isinstance(other, self.__class__)
1166
 
 
1167
 
    def __ne__(self, other):
1168
 
        return not self == other
 
811
    _default_format = None
 
812
    """The default format used for new repositories."""
 
813
 
 
814
    _formats = {}
 
815
    """The known formats."""
1169
816
 
1170
817
    @classmethod
1171
818
    def find_format(klass, a_bzrdir):
1172
 
        """Return the format for the repository object in a_bzrdir.
1173
 
        
1174
 
        This is used by bzr native formats that have a "format" file in
1175
 
        the repository.  Other methods may be used by different types of 
1176
 
        control directory.
1177
 
        """
 
819
        """Return the format for the repository object in a_bzrdir."""
1178
820
        try:
1179
821
            transport = a_bzrdir.get_repository_transport(None)
1180
822
            format_string = transport.get("format").read()
1181
 
            return format_registry.get(format_string)
 
823
            return klass._formats[format_string]
1182
824
        except errors.NoSuchFile:
1183
825
            raise errors.NoRepositoryPresent(a_bzrdir)
1184
826
        except KeyError:
1185
 
            raise errors.UnknownFormatError(format=format_string)
1186
 
 
1187
 
    @classmethod
1188
 
    def register_format(klass, format):
1189
 
        format_registry.register(format.get_format_string(), format)
1190
 
 
1191
 
    @classmethod
1192
 
    def unregister_format(klass, format):
1193
 
        format_registry.remove(format.get_format_string())
 
827
            raise errors.UnknownFormatError(format_string)
 
828
 
 
829
    def _get_control_store(self, repo_transport, control_files):
 
830
        """Return the control store for this repository."""
 
831
        raise NotImplementedError(self._get_control_store)
1194
832
    
1195
833
    @classmethod
1196
834
    def get_default_format(klass):
1197
835
        """Return the current default format."""
1198
 
        from bzrlib import bzrdir
1199
 
        return bzrdir.format_registry.make_bzrdir('default').repository_format
1200
 
 
1201
 
    def _get_control_store(self, repo_transport, control_files):
1202
 
        """Return the control store for this repository."""
1203
 
        raise NotImplementedError(self._get_control_store)
 
836
        return klass._default_format
1204
837
 
1205
838
    def get_format_string(self):
1206
839
        """Return the ASCII format string that identifies this format.
1211
844
        raise NotImplementedError(self.get_format_string)
1212
845
 
1213
846
    def get_format_description(self):
1214
 
        """Return the short description for this format."""
 
847
        """Return the short desciption for this format."""
1215
848
        raise NotImplementedError(self.get_format_description)
1216
849
 
1217
850
    def _get_revision_store(self, repo_transport, control_files):
1233
866
        from bzrlib.store.revision.text import TextRevisionStore
1234
867
        dir_mode = control_files._dir_mode
1235
868
        file_mode = control_files._file_mode
1236
 
        text_store = TextStore(transport.clone(name),
 
869
        text_store =TextStore(transport.clone(name),
1237
870
                              prefixed=prefixed,
1238
871
                              compressed=compressed,
1239
872
                              dir_mode=dir_mode,
1241
874
        _revision_store = TextRevisionStore(text_store, serializer)
1242
875
        return _revision_store
1243
876
 
1244
 
    # TODO: this shouldn't be in the base class, it's specific to things that
1245
 
    # use weaves or knits -- mbp 20070207
1246
877
    def _get_versioned_file_store(self,
1247
878
                                  name,
1248
879
                                  transport,
1249
880
                                  control_files,
1250
881
                                  prefixed=True,
1251
 
                                  versionedfile_class=None,
1252
 
                                  versionedfile_kwargs={},
 
882
                                  versionedfile_class=WeaveFile,
1253
883
                                  escaped=False):
1254
 
        if versionedfile_class is None:
1255
 
            versionedfile_class = self._versionedfile_class
1256
884
        weave_transport = control_files._transport.clone(name)
1257
885
        dir_mode = control_files._dir_mode
1258
886
        file_mode = control_files._file_mode
1260
888
                                  dir_mode=dir_mode,
1261
889
                                  file_mode=file_mode,
1262
890
                                  versionedfile_class=versionedfile_class,
1263
 
                                  versionedfile_kwargs=versionedfile_kwargs,
1264
891
                                  escaped=escaped)
1265
892
 
1266
893
    def initialize(self, a_bzrdir, shared=False):
1268
895
 
1269
896
        :param a_bzrdir: The bzrdir to put the new repository in it.
1270
897
        :param shared: The repository should be initialized as a sharable one.
1271
 
        :returns: The new repository object.
1272
 
        
 
898
 
1273
899
        This may raise UninitializableFormat if shared repository are not
1274
900
        compatible the a_bzrdir.
1275
901
        """
1276
 
        raise NotImplementedError(self.initialize)
1277
902
 
1278
903
    def is_supported(self):
1279
904
        """Is this format supported?
1284
909
        """
1285
910
        return True
1286
911
 
1287
 
    def check_conversion_target(self, target_format):
1288
 
        raise NotImplementedError(self.check_conversion_target)
1289
 
 
1290
912
    def open(self, a_bzrdir, _found=False):
1291
913
        """Return an instance of this format for the bzrdir a_bzrdir.
1292
914
        
1294
916
        """
1295
917
        raise NotImplementedError(self.open)
1296
918
 
 
919
    @classmethod
 
920
    def register_format(klass, format):
 
921
        klass._formats[format.get_format_string()] = format
 
922
 
 
923
    @classmethod
 
924
    def set_default_format(klass, format):
 
925
        klass._default_format = format
 
926
 
 
927
    @classmethod
 
928
    def unregister_format(klass, format):
 
929
        assert klass._formats[format.get_format_string()] is format
 
930
        del klass._formats[format.get_format_string()]
 
931
 
 
932
 
 
933
class PreSplitOutRepositoryFormat(RepositoryFormat):
 
934
    """Base class for the pre split out repository formats."""
 
935
 
 
936
    def initialize(self, a_bzrdir, shared=False, _internal=False):
 
937
        """Create a weave repository.
 
938
        
 
939
        TODO: when creating split out bzr branch formats, move this to a common
 
940
        base for Format5, Format6. or something like that.
 
941
        """
 
942
        from bzrlib.weavefile import write_weave_v5
 
943
        from bzrlib.weave import Weave
 
944
 
 
945
        if shared:
 
946
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
 
947
 
 
948
        if not _internal:
 
949
            # always initialized when the bzrdir is.
 
950
            return self.open(a_bzrdir, _found=True)
 
951
        
 
952
        # Create an empty weave
 
953
        sio = StringIO()
 
954
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
 
955
        empty_weave = sio.getvalue()
 
956
 
 
957
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
958
        dirs = ['revision-store', 'weaves']
 
959
        files = [('inventory.weave', StringIO(empty_weave)),
 
960
                 ]
 
961
        
 
962
        # FIXME: RBC 20060125 dont peek under the covers
 
963
        # NB: no need to escape relative paths that are url safe.
 
964
        control_files = LockableFiles(a_bzrdir.transport, 'branch-lock',
 
965
                                      TransportLock)
 
966
        control_files.create_lock()
 
967
        control_files.lock_write()
 
968
        control_files._transport.mkdir_multi(dirs,
 
969
                mode=control_files._dir_mode)
 
970
        try:
 
971
            for file, content in files:
 
972
                control_files.put(file, content)
 
973
        finally:
 
974
            control_files.unlock()
 
975
        return self.open(a_bzrdir, _found=True)
 
976
 
 
977
    def _get_control_store(self, repo_transport, control_files):
 
978
        """Return the control store for this repository."""
 
979
        return self._get_versioned_file_store('',
 
980
                                              repo_transport,
 
981
                                              control_files,
 
982
                                              prefixed=False)
 
983
 
 
984
    def _get_text_store(self, transport, control_files):
 
985
        """Get a store for file texts for this format."""
 
986
        raise NotImplementedError(self._get_text_store)
 
987
 
 
988
    def open(self, a_bzrdir, _found=False):
 
989
        """See RepositoryFormat.open()."""
 
990
        if not _found:
 
991
            # we are being called directly and must probe.
 
992
            raise NotImplementedError
 
993
 
 
994
        repo_transport = a_bzrdir.get_repository_transport(None)
 
995
        control_files = a_bzrdir._control_files
 
996
        text_store = self._get_text_store(repo_transport, control_files)
 
997
        control_store = self._get_control_store(repo_transport, control_files)
 
998
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
999
        return AllInOneRepository(_format=self,
 
1000
                                  a_bzrdir=a_bzrdir,
 
1001
                                  _revision_store=_revision_store,
 
1002
                                  control_store=control_store,
 
1003
                                  text_store=text_store)
 
1004
 
 
1005
 
 
1006
class RepositoryFormat4(PreSplitOutRepositoryFormat):
 
1007
    """Bzr repository format 4.
 
1008
 
 
1009
    This repository format has:
 
1010
     - flat stores
 
1011
     - TextStores for texts, inventories,revisions.
 
1012
 
 
1013
    This format is deprecated: it indexes texts using a text id which is
 
1014
    removed in format 5; initializationa and write support for this format
 
1015
    has been removed.
 
1016
    """
 
1017
 
 
1018
    def __init__(self):
 
1019
        super(RepositoryFormat4, self).__init__()
 
1020
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat4()
 
1021
 
 
1022
    def get_format_description(self):
 
1023
        """See RepositoryFormat.get_format_description()."""
 
1024
        return "Repository format 4"
 
1025
 
 
1026
    def initialize(self, url, shared=False, _internal=False):
 
1027
        """Format 4 branches cannot be created."""
 
1028
        raise errors.UninitializableFormat(self)
 
1029
 
 
1030
    def is_supported(self):
 
1031
        """Format 4 is not supported.
 
1032
 
 
1033
        It is not supported because the model changed from 4 to 5 and the
 
1034
        conversion logic is expensive - so doing it on the fly was not 
 
1035
        feasible.
 
1036
        """
 
1037
        return False
 
1038
 
 
1039
    def _get_control_store(self, repo_transport, control_files):
 
1040
        """Format 4 repositories have no formal control store at this point.
 
1041
        
 
1042
        This will cause any control-file-needing apis to fail - this is desired.
 
1043
        """
 
1044
        return None
 
1045
    
 
1046
    def _get_revision_store(self, repo_transport, control_files):
 
1047
        """See RepositoryFormat._get_revision_store()."""
 
1048
        from bzrlib.xml4 import serializer_v4
 
1049
        return self._get_text_rev_store(repo_transport,
 
1050
                                        control_files,
 
1051
                                        'revision-store',
 
1052
                                        serializer=serializer_v4)
 
1053
 
 
1054
    def _get_text_store(self, transport, control_files):
 
1055
        """See RepositoryFormat._get_text_store()."""
 
1056
 
 
1057
 
 
1058
class RepositoryFormat5(PreSplitOutRepositoryFormat):
 
1059
    """Bzr control format 5.
 
1060
 
 
1061
    This repository format has:
 
1062
     - weaves for file texts and inventory
 
1063
     - flat stores
 
1064
     - TextStores for revisions and signatures.
 
1065
    """
 
1066
 
 
1067
    def __init__(self):
 
1068
        super(RepositoryFormat5, self).__init__()
 
1069
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat5()
 
1070
 
 
1071
    def get_format_description(self):
 
1072
        """See RepositoryFormat.get_format_description()."""
 
1073
        return "Weave repository format 5"
 
1074
 
 
1075
    def _get_revision_store(self, repo_transport, control_files):
 
1076
        """See RepositoryFormat._get_revision_store()."""
 
1077
        """Return the revision store object for this a_bzrdir."""
 
1078
        return self._get_text_rev_store(repo_transport,
 
1079
                                        control_files,
 
1080
                                        'revision-store',
 
1081
                                        compressed=False)
 
1082
 
 
1083
    def _get_text_store(self, transport, control_files):
 
1084
        """See RepositoryFormat._get_text_store()."""
 
1085
        return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
 
1086
 
 
1087
 
 
1088
class RepositoryFormat6(PreSplitOutRepositoryFormat):
 
1089
    """Bzr control format 6.
 
1090
 
 
1091
    This repository format has:
 
1092
     - weaves for file texts and inventory
 
1093
     - hash subdirectory based stores.
 
1094
     - TextStores for revisions and signatures.
 
1095
    """
 
1096
 
 
1097
    def __init__(self):
 
1098
        super(RepositoryFormat6, self).__init__()
 
1099
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirFormat6()
 
1100
 
 
1101
    def get_format_description(self):
 
1102
        """See RepositoryFormat.get_format_description()."""
 
1103
        return "Weave repository format 6"
 
1104
 
 
1105
    def _get_revision_store(self, repo_transport, control_files):
 
1106
        """See RepositoryFormat._get_revision_store()."""
 
1107
        return self._get_text_rev_store(repo_transport,
 
1108
                                        control_files,
 
1109
                                        'revision-store',
 
1110
                                        compressed=False,
 
1111
                                        prefixed=True)
 
1112
 
 
1113
    def _get_text_store(self, transport, control_files):
 
1114
        """See RepositoryFormat._get_text_store()."""
 
1115
        return self._get_versioned_file_store('weaves', transport, control_files)
 
1116
 
1297
1117
 
1298
1118
class MetaDirRepositoryFormat(RepositoryFormat):
1299
 
    """Common base class for the new repositories using the metadir layout."""
1300
 
 
1301
 
    rich_root_data = False
1302
 
    supports_tree_reference = False
1303
 
    _matchingbzrdir = bzrdir.BzrDirMetaFormat1()
 
1119
    """Common base class for the new repositories using the metadir layour."""
1304
1120
 
1305
1121
    def __init__(self):
1306
1122
        super(MetaDirRepositoryFormat, self).__init__()
 
1123
        self._matchingbzrdir = bzrlib.bzrdir.BzrDirMetaFormat1()
1307
1124
 
1308
1125
    def _create_control_files(self, a_bzrdir):
1309
1126
        """Create the required files and the initial control_files object."""
1310
 
        # FIXME: RBC 20060125 don't peek under the covers
 
1127
        # FIXME: RBC 20060125 dont peek under the covers
1311
1128
        # NB: no need to escape relative paths that are url safe.
1312
1129
        repository_transport = a_bzrdir.get_repository_transport(self)
1313
 
        control_files = lockable_files.LockableFiles(repository_transport,
1314
 
                                'lock', lockdir.LockDir)
 
1130
        control_files = LockableFiles(repository_transport, 'lock', LockDir)
1315
1131
        control_files.create_lock()
1316
1132
        return control_files
1317
1133
 
1332
1148
            control_files.unlock()
1333
1149
 
1334
1150
 
 
1151
class RepositoryFormat7(MetaDirRepositoryFormat):
 
1152
    """Bzr repository 7.
 
1153
 
 
1154
    This repository format has:
 
1155
     - weaves for file texts and inventory
 
1156
     - hash subdirectory based stores.
 
1157
     - TextStores for revisions and signatures.
 
1158
     - a format marker of its own
 
1159
     - an optional 'shared-storage' flag
 
1160
     - an optional 'no-working-trees' flag
 
1161
    """
 
1162
 
 
1163
    def _get_control_store(self, repo_transport, control_files):
 
1164
        """Return the control store for this repository."""
 
1165
        return self._get_versioned_file_store('',
 
1166
                                              repo_transport,
 
1167
                                              control_files,
 
1168
                                              prefixed=False)
 
1169
 
 
1170
    def get_format_string(self):
 
1171
        """See RepositoryFormat.get_format_string()."""
 
1172
        return "Bazaar-NG Repository format 7"
 
1173
 
 
1174
    def get_format_description(self):
 
1175
        """See RepositoryFormat.get_format_description()."""
 
1176
        return "Weave repository format 7"
 
1177
 
 
1178
    def _get_revision_store(self, repo_transport, control_files):
 
1179
        """See RepositoryFormat._get_revision_store()."""
 
1180
        return self._get_text_rev_store(repo_transport,
 
1181
                                        control_files,
 
1182
                                        'revision-store',
 
1183
                                        compressed=False,
 
1184
                                        prefixed=True,
 
1185
                                        )
 
1186
 
 
1187
    def _get_text_store(self, transport, control_files):
 
1188
        """See RepositoryFormat._get_text_store()."""
 
1189
        return self._get_versioned_file_store('weaves',
 
1190
                                              transport,
 
1191
                                              control_files)
 
1192
 
 
1193
    def initialize(self, a_bzrdir, shared=False):
 
1194
        """Create a weave repository.
 
1195
 
 
1196
        :param shared: If true the repository will be initialized as a shared
 
1197
                       repository.
 
1198
        """
 
1199
        from bzrlib.weavefile import write_weave_v5
 
1200
        from bzrlib.weave import Weave
 
1201
 
 
1202
        # Create an empty weave
 
1203
        sio = StringIO()
 
1204
        bzrlib.weavefile.write_weave_v5(Weave(), sio)
 
1205
        empty_weave = sio.getvalue()
 
1206
 
 
1207
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
1208
        dirs = ['revision-store', 'weaves']
 
1209
        files = [('inventory.weave', StringIO(empty_weave)), 
 
1210
                 ]
 
1211
        utf8_files = [('format', self.get_format_string())]
 
1212
 
 
1213
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
1214
        return self.open(a_bzrdir=a_bzrdir, _found=True)
 
1215
 
 
1216
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
1217
        """See RepositoryFormat.open().
 
1218
        
 
1219
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
1220
                                    repository at a slightly different url
 
1221
                                    than normal. I.e. during 'upgrade'.
 
1222
        """
 
1223
        if not _found:
 
1224
            format = RepositoryFormat.find_format(a_bzrdir)
 
1225
            assert format.__class__ ==  self.__class__
 
1226
        if _override_transport is not None:
 
1227
            repo_transport = _override_transport
 
1228
        else:
 
1229
            repo_transport = a_bzrdir.get_repository_transport(None)
 
1230
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
 
1231
        text_store = self._get_text_store(repo_transport, control_files)
 
1232
        control_store = self._get_control_store(repo_transport, control_files)
 
1233
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1234
        return MetaDirRepository(_format=self,
 
1235
                                 a_bzrdir=a_bzrdir,
 
1236
                                 control_files=control_files,
 
1237
                                 _revision_store=_revision_store,
 
1238
                                 control_store=control_store,
 
1239
                                 text_store=text_store)
 
1240
 
 
1241
 
 
1242
class RepositoryFormatKnit1(MetaDirRepositoryFormat):
 
1243
    """Bzr repository knit format 1.
 
1244
 
 
1245
    This repository format has:
 
1246
     - knits for file texts and inventory
 
1247
     - hash subdirectory based stores.
 
1248
     - knits for revisions and signatures
 
1249
     - TextStores for revisions and signatures.
 
1250
     - a format marker of its own
 
1251
     - an optional 'shared-storage' flag
 
1252
     - an optional 'no-working-trees' flag
 
1253
     - a LockDir lock
 
1254
 
 
1255
    This format was introduced in bzr 0.8.
 
1256
    """
 
1257
 
 
1258
    def _get_control_store(self, repo_transport, control_files):
 
1259
        """Return the control store for this repository."""
 
1260
        return VersionedFileStore(
 
1261
            repo_transport,
 
1262
            prefixed=False,
 
1263
            file_mode=control_files._file_mode,
 
1264
            versionedfile_class=KnitVersionedFile,
 
1265
            versionedfile_kwargs={'factory':KnitPlainFactory()},
 
1266
            )
 
1267
 
 
1268
    def get_format_string(self):
 
1269
        """See RepositoryFormat.get_format_string()."""
 
1270
        return "Bazaar-NG Knit Repository Format 1"
 
1271
 
 
1272
    def get_format_description(self):
 
1273
        """See RepositoryFormat.get_format_description()."""
 
1274
        return "Knit repository format 1"
 
1275
 
 
1276
    def _get_revision_store(self, repo_transport, control_files):
 
1277
        """See RepositoryFormat._get_revision_store()."""
 
1278
        from bzrlib.store.revision.knit import KnitRevisionStore
 
1279
        versioned_file_store = VersionedFileStore(
 
1280
            repo_transport,
 
1281
            file_mode=control_files._file_mode,
 
1282
            prefixed=False,
 
1283
            precious=True,
 
1284
            versionedfile_class=KnitVersionedFile,
 
1285
            versionedfile_kwargs={'delta':False, 'factory':KnitPlainFactory()},
 
1286
            escaped=True,
 
1287
            )
 
1288
        return KnitRevisionStore(versioned_file_store)
 
1289
 
 
1290
    def _get_text_store(self, transport, control_files):
 
1291
        """See RepositoryFormat._get_text_store()."""
 
1292
        return self._get_versioned_file_store('knits',
 
1293
                                              transport,
 
1294
                                              control_files,
 
1295
                                              versionedfile_class=KnitVersionedFile,
 
1296
                                              escaped=True)
 
1297
 
 
1298
    def initialize(self, a_bzrdir, shared=False):
 
1299
        """Create a knit format 1 repository.
 
1300
 
 
1301
        :param a_bzrdir: bzrdir to contain the new repository; must already
 
1302
            be initialized.
 
1303
        :param shared: If true the repository will be initialized as a shared
 
1304
                       repository.
 
1305
        """
 
1306
        mutter('creating repository in %s.', a_bzrdir.transport.base)
 
1307
        dirs = ['revision-store', 'knits']
 
1308
        files = []
 
1309
        utf8_files = [('format', self.get_format_string())]
 
1310
        
 
1311
        self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
 
1312
        repo_transport = a_bzrdir.get_repository_transport(None)
 
1313
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
 
1314
        control_store = self._get_control_store(repo_transport, control_files)
 
1315
        transaction = bzrlib.transactions.WriteTransaction()
 
1316
        # trigger a write of the inventory store.
 
1317
        control_store.get_weave_or_empty('inventory', transaction)
 
1318
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1319
        _revision_store.has_revision_id('A', transaction)
 
1320
        _revision_store.get_signature_file(transaction)
 
1321
        return self.open(a_bzrdir=a_bzrdir, _found=True)
 
1322
 
 
1323
    def open(self, a_bzrdir, _found=False, _override_transport=None):
 
1324
        """See RepositoryFormat.open().
 
1325
        
 
1326
        :param _override_transport: INTERNAL USE ONLY. Allows opening the
 
1327
                                    repository at a slightly different url
 
1328
                                    than normal. I.e. during 'upgrade'.
 
1329
        """
 
1330
        if not _found:
 
1331
            format = RepositoryFormat.find_format(a_bzrdir)
 
1332
            assert format.__class__ ==  self.__class__
 
1333
        if _override_transport is not None:
 
1334
            repo_transport = _override_transport
 
1335
        else:
 
1336
            repo_transport = a_bzrdir.get_repository_transport(None)
 
1337
        control_files = LockableFiles(repo_transport, 'lock', LockDir)
 
1338
        text_store = self._get_text_store(repo_transport, control_files)
 
1339
        control_store = self._get_control_store(repo_transport, control_files)
 
1340
        _revision_store = self._get_revision_store(repo_transport, control_files)
 
1341
        return KnitRepository(_format=self,
 
1342
                              a_bzrdir=a_bzrdir,
 
1343
                              control_files=control_files,
 
1344
                              _revision_store=_revision_store,
 
1345
                              control_store=control_store,
 
1346
                              text_store=text_store)
 
1347
 
 
1348
 
1335
1349
# formats which have no format string are not discoverable
1336
 
# and not independently creatable, so are not registered.  They're 
1337
 
# all in bzrlib.repofmt.weaverepo now.  When an instance of one of these is
1338
 
# needed, it's constructed directly by the BzrDir.  Non-native formats where
1339
 
# the repository is not separately opened are similar.
1340
 
 
1341
 
format_registry.register_lazy(
1342
 
    'Bazaar-NG Repository format 7',
1343
 
    'bzrlib.repofmt.weaverepo',
1344
 
    'RepositoryFormat7'
1345
 
    )
1346
 
# KEEP in sync with bzrdir.format_registry default, which controls the overall
1347
 
# default control directory format
1348
 
 
1349
 
format_registry.register_lazy(
1350
 
    'Bazaar-NG Knit Repository Format 1',
1351
 
    'bzrlib.repofmt.knitrepo',
1352
 
    'RepositoryFormatKnit1',
1353
 
    )
1354
 
format_registry.default_key = 'Bazaar-NG Knit Repository Format 1'
1355
 
 
1356
 
format_registry.register_lazy(
1357
 
    'Bazaar Knit Repository Format 3 (bzr 0.15)\n',
1358
 
    'bzrlib.repofmt.knitrepo',
1359
 
    'RepositoryFormatKnit3',
1360
 
    )
 
1350
# and not independently creatable, so are not registered.
 
1351
RepositoryFormat.register_format(RepositoryFormat7())
 
1352
_default_format = RepositoryFormatKnit1()
 
1353
RepositoryFormat.register_format(_default_format)
 
1354
RepositoryFormat.set_default_format(_default_format)
 
1355
_legacy_formats = [RepositoryFormat4(),
 
1356
                   RepositoryFormat5(),
 
1357
                   RepositoryFormat6()]
1361
1358
 
1362
1359
 
1363
1360
class InterRepository(InterObject):
1372
1369
    InterRepository.get(other).method_name(parameters).
1373
1370
    """
1374
1371
 
1375
 
    _optimisers = []
 
1372
    _optimisers = set()
1376
1373
    """The available optimised InterRepository types."""
1377
1374
 
1378
 
    def copy_content(self, revision_id=None):
1379
 
        raise NotImplementedError(self.copy_content)
1380
 
 
 
1375
    @needs_write_lock
 
1376
    def copy_content(self, revision_id=None, basis=None):
 
1377
        """Make a complete copy of the content in self into destination.
 
1378
        
 
1379
        This is a destructive operation! Do not use it on existing 
 
1380
        repositories.
 
1381
 
 
1382
        :param revision_id: Only copy the content needed to construct
 
1383
                            revision_id and its parents.
 
1384
        :param basis: Copy the needed data preferentially from basis.
 
1385
        """
 
1386
        try:
 
1387
            self.target.set_make_working_trees(self.source.make_working_trees())
 
1388
        except NotImplementedError:
 
1389
            pass
 
1390
        # grab the basis available data
 
1391
        if basis is not None:
 
1392
            self.target.fetch(basis, revision_id=revision_id)
 
1393
        # but dont bother fetching if we have the needed data now.
 
1394
        if (revision_id not in (None, NULL_REVISION) and 
 
1395
            self.target.has_revision(revision_id)):
 
1396
            return
 
1397
        self.target.fetch(self.source, revision_id=revision_id)
 
1398
 
 
1399
    def _double_lock(self, lock_source, lock_target):
 
1400
        """Take out too locks, rolling back the first if the second throws."""
 
1401
        lock_source()
 
1402
        try:
 
1403
            lock_target()
 
1404
        except Exception:
 
1405
            # we want to ensure that we don't leave source locked by mistake.
 
1406
            # and any error on target should not confuse source.
 
1407
            self.source.unlock()
 
1408
            raise
 
1409
 
 
1410
    @needs_write_lock
1381
1411
    def fetch(self, revision_id=None, pb=None):
1382
1412
        """Fetch the content required to construct revision_id.
1383
1413
 
1384
 
        The content is copied from self.source to self.target.
 
1414
        The content is copied from source to target.
1385
1415
 
1386
1416
        :param revision_id: if None all content is copied, if NULL_REVISION no
1387
1417
                            content is copied.
1391
1421
        Returns the copied revision count and the failed revisions in a tuple:
1392
1422
        (copied, failures).
1393
1423
        """
1394
 
        raise NotImplementedError(self.fetch)
1395
 
   
 
1424
        from bzrlib.fetch import GenericRepoFetcher
 
1425
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
 
1426
               self.source, self.source._format, self.target, self.target._format)
 
1427
        f = GenericRepoFetcher(to_repository=self.target,
 
1428
                               from_repository=self.source,
 
1429
                               last_revision=revision_id,
 
1430
                               pb=pb)
 
1431
        return f.count_copied, f.failed_revisions
 
1432
 
 
1433
    def lock_read(self):
 
1434
        """Take out a logical read lock.
 
1435
 
 
1436
        This will lock the source branch and the target branch. The source gets
 
1437
        a read lock and the target a read lock.
 
1438
        """
 
1439
        self._double_lock(self.source.lock_read, self.target.lock_read)
 
1440
 
 
1441
    def lock_write(self):
 
1442
        """Take out a logical write lock.
 
1443
 
 
1444
        This will lock the source branch and the target branch. The source gets
 
1445
        a read lock and the target a write lock.
 
1446
        """
 
1447
        self._double_lock(self.source.lock_read, self.target.lock_write)
 
1448
 
1396
1449
    @needs_read_lock
1397
1450
    def missing_revision_ids(self, revision_id=None):
1398
1451
        """Return the revision ids that source has that target does not.
1405
1458
        # generic, possibly worst case, slow code path.
1406
1459
        target_ids = set(self.target.all_revision_ids())
1407
1460
        if revision_id is not None:
1408
 
            # TODO: jam 20070210 InterRepository is internal enough that it
1409
 
            #       should assume revision_ids are already utf-8
1410
 
            revision_id = osutils.safe_revision_id(revision_id)
1411
1461
            source_ids = self.source.get_ancestry(revision_id)
1412
 
            assert source_ids[0] is None
1413
 
            source_ids.pop(0)
 
1462
            assert source_ids.pop(0) == None
1414
1463
        else:
1415
1464
            source_ids = self.source.all_revision_ids()
1416
1465
        result_set = set(source_ids).difference(target_ids)
1419
1468
        # that we've decided we need.
1420
1469
        return [rev_id for rev_id in source_ids if rev_id in result_set]
1421
1470
 
1422
 
 
1423
 
class InterSameDataRepository(InterRepository):
1424
 
    """Code for converting between repositories that represent the same data.
1425
 
    
1426
 
    Data format and model must match for this to work.
1427
 
    """
1428
 
 
1429
 
    @classmethod
1430
 
    def _get_repo_format_to_test(self):
1431
 
        """Repository format for testing with."""
1432
 
        return RepositoryFormat.get_default_format()
1433
 
 
1434
 
    @staticmethod
1435
 
    def is_compatible(source, target):
1436
 
        if source.supports_rich_root() != target.supports_rich_root():
1437
 
            return False
1438
 
        if source._serializer != target._serializer:
1439
 
            return False
1440
 
        return True
1441
 
 
1442
 
    @needs_write_lock
1443
 
    def copy_content(self, revision_id=None):
1444
 
        """Make a complete copy of the content in self into destination.
1445
 
 
1446
 
        This copies both the repository's revision data, and configuration information
1447
 
        such as the make_working_trees setting.
1448
 
        
1449
 
        This is a destructive operation! Do not use it on existing 
1450
 
        repositories.
1451
 
 
1452
 
        :param revision_id: Only copy the content needed to construct
1453
 
                            revision_id and its parents.
1454
 
        """
 
1471
    def unlock(self):
 
1472
        """Release the locks on source and target."""
1455
1473
        try:
1456
 
            self.target.set_make_working_trees(self.source.make_working_trees())
1457
 
        except NotImplementedError:
1458
 
            pass
1459
 
        # TODO: jam 20070210 This is fairly internal, so we should probably
1460
 
        #       just assert that revision_id is not unicode.
1461
 
        revision_id = osutils.safe_revision_id(revision_id)
1462
 
        # but don't bother fetching if we have the needed data now.
1463
 
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
1464
 
            self.target.has_revision(revision_id)):
1465
 
            return
1466
 
        self.target.fetch(self.source, revision_id=revision_id)
1467
 
 
1468
 
    @needs_write_lock
1469
 
    def fetch(self, revision_id=None, pb=None):
1470
 
        """See InterRepository.fetch()."""
1471
 
        from bzrlib.fetch import GenericRepoFetcher
1472
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1473
 
               self.source, self.source._format, self.target, 
1474
 
               self.target._format)
1475
 
        # TODO: jam 20070210 This should be an assert, not a translate
1476
 
        revision_id = osutils.safe_revision_id(revision_id)
1477
 
        f = GenericRepoFetcher(to_repository=self.target,
1478
 
                               from_repository=self.source,
1479
 
                               last_revision=revision_id,
1480
 
                               pb=pb)
1481
 
        return f.count_copied, f.failed_revisions
1482
 
 
1483
 
 
1484
 
class InterWeaveRepo(InterSameDataRepository):
 
1474
            self.target.unlock()
 
1475
        finally:
 
1476
            self.source.unlock()
 
1477
 
 
1478
 
 
1479
class InterWeaveRepo(InterRepository):
1485
1480
    """Optimised code paths between Weave based repositories."""
1486
1481
 
1487
 
    @classmethod
1488
 
    def _get_repo_format_to_test(self):
1489
 
        from bzrlib.repofmt import weaverepo
1490
 
        return weaverepo.RepositoryFormat7()
 
1482
    _matching_repo_format = RepositoryFormat7()
 
1483
    """Repository format for testing with."""
1491
1484
 
1492
1485
    @staticmethod
1493
1486
    def is_compatible(source, target):
1494
1487
        """Be compatible with known Weave formats.
1495
1488
        
1496
 
        We don't test for the stores being of specific types because that
 
1489
        We dont test for the stores being of specific types becase that
1497
1490
        could lead to confusing results, and there is no need to be 
1498
1491
        overly general.
1499
1492
        """
1500
 
        from bzrlib.repofmt.weaverepo import (
1501
 
                RepositoryFormat5,
1502
 
                RepositoryFormat6,
1503
 
                RepositoryFormat7,
1504
 
                )
1505
1493
        try:
1506
1494
            return (isinstance(source._format, (RepositoryFormat5,
1507
1495
                                                RepositoryFormat6,
1513
1501
            return False
1514
1502
    
1515
1503
    @needs_write_lock
1516
 
    def copy_content(self, revision_id=None):
 
1504
    def copy_content(self, revision_id=None, basis=None):
1517
1505
        """See InterRepository.copy_content()."""
1518
1506
        # weave specific optimised path:
1519
 
        # TODO: jam 20070210 Internal, should be an assert, not translate
1520
 
        revision_id = osutils.safe_revision_id(revision_id)
1521
 
        try:
1522
 
            self.target.set_make_working_trees(self.source.make_working_trees())
1523
 
        except NotImplementedError:
1524
 
            pass
1525
 
        # FIXME do not peek!
1526
 
        if self.source.control_files._transport.listable():
1527
 
            pb = ui.ui_factory.nested_progress_bar()
 
1507
        if basis is not None:
 
1508
            # copy the basis in, then fetch remaining data.
 
1509
            basis.copy_content_into(self.target, revision_id)
 
1510
            # the basis copy_content_into could misset this.
1528
1511
            try:
1529
 
                self.target.weave_store.copy_all_ids(
1530
 
                    self.source.weave_store,
1531
 
                    pb=pb,
1532
 
                    from_transaction=self.source.get_transaction(),
1533
 
                    to_transaction=self.target.get_transaction())
1534
 
                pb.update('copying inventory', 0, 1)
1535
 
                self.target.control_weaves.copy_multi(
1536
 
                    self.source.control_weaves, ['inventory'],
1537
 
                    from_transaction=self.source.get_transaction(),
1538
 
                    to_transaction=self.target.get_transaction())
1539
 
                self.target._revision_store.text_store.copy_all_ids(
1540
 
                    self.source._revision_store.text_store,
1541
 
                    pb=pb)
1542
 
            finally:
1543
 
                pb.finished()
1544
 
        else:
 
1512
                self.target.set_make_working_trees(self.source.make_working_trees())
 
1513
            except NotImplementedError:
 
1514
                pass
1545
1515
            self.target.fetch(self.source, revision_id=revision_id)
 
1516
        else:
 
1517
            try:
 
1518
                self.target.set_make_working_trees(self.source.make_working_trees())
 
1519
            except NotImplementedError:
 
1520
                pass
 
1521
            # FIXME do not peek!
 
1522
            if self.source.control_files._transport.listable():
 
1523
                pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1524
                try:
 
1525
                    self.target.weave_store.copy_all_ids(
 
1526
                        self.source.weave_store,
 
1527
                        pb=pb,
 
1528
                        from_transaction=self.source.get_transaction(),
 
1529
                        to_transaction=self.target.get_transaction())
 
1530
                    pb.update('copying inventory', 0, 1)
 
1531
                    self.target.control_weaves.copy_multi(
 
1532
                        self.source.control_weaves, ['inventory'],
 
1533
                        from_transaction=self.source.get_transaction(),
 
1534
                        to_transaction=self.target.get_transaction())
 
1535
                    self.target._revision_store.text_store.copy_all_ids(
 
1536
                        self.source._revision_store.text_store,
 
1537
                        pb=pb)
 
1538
                finally:
 
1539
                    pb.finished()
 
1540
            else:
 
1541
                self.target.fetch(self.source, revision_id=revision_id)
1546
1542
 
1547
1543
    @needs_write_lock
1548
1544
    def fetch(self, revision_id=None, pb=None):
1550
1546
        from bzrlib.fetch import GenericRepoFetcher
1551
1547
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1552
1548
               self.source, self.source._format, self.target, self.target._format)
1553
 
        # TODO: jam 20070210 This should be an assert, not a translate
1554
 
        revision_id = osutils.safe_revision_id(revision_id)
1555
1549
        f = GenericRepoFetcher(to_repository=self.target,
1556
1550
                               from_repository=self.source,
1557
1551
                               last_revision=revision_id,
1562
1556
    def missing_revision_ids(self, revision_id=None):
1563
1557
        """See InterRepository.missing_revision_ids()."""
1564
1558
        # we want all revisions to satisfy revision_id in source.
1565
 
        # but we don't want to stat every file here and there.
 
1559
        # but we dont want to stat every file here and there.
1566
1560
        # we want then, all revisions other needs to satisfy revision_id 
1567
1561
        # checked, but not those that we have locally.
1568
1562
        # so the first thing is to get a subset of the revisions to 
1574
1568
        # - RBC 20060209
1575
1569
        if revision_id is not None:
1576
1570
            source_ids = self.source.get_ancestry(revision_id)
1577
 
            assert source_ids[0] is None
1578
 
            source_ids.pop(0)
 
1571
            assert source_ids.pop(0) == None
1579
1572
        else:
1580
1573
            source_ids = self.source._all_possible_ids()
1581
1574
        source_ids_set = set(source_ids)
1582
1575
        # source_ids is the worst possible case we may need to pull.
1583
1576
        # now we want to filter source_ids against what we actually
1584
 
        # have in target, but don't try to check for existence where we know
 
1577
        # have in target, but dont try to check for existence where we know
1585
1578
        # we do not have a revision as that would be pointless.
1586
1579
        target_ids = set(self.target._all_possible_ids())
1587
1580
        possibly_present_revisions = target_ids.intersection(source_ids_set)
1600
1593
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
1601
1594
 
1602
1595
 
1603
 
class InterKnitRepo(InterSameDataRepository):
 
1596
class InterKnitRepo(InterRepository):
1604
1597
    """Optimised code paths between Knit based repositories."""
1605
1598
 
1606
 
    @classmethod
1607
 
    def _get_repo_format_to_test(self):
1608
 
        from bzrlib.repofmt import knitrepo
1609
 
        return knitrepo.RepositoryFormatKnit1()
 
1599
    _matching_repo_format = RepositoryFormatKnit1()
 
1600
    """Repository format for testing with."""
1610
1601
 
1611
1602
    @staticmethod
1612
1603
    def is_compatible(source, target):
1613
1604
        """Be compatible with known Knit formats.
1614
1605
        
1615
 
        We don't test for the stores being of specific types because that
 
1606
        We dont test for the stores being of specific types becase that
1616
1607
        could lead to confusing results, and there is no need to be 
1617
1608
        overly general.
1618
1609
        """
1619
 
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1
1620
1610
        try:
1621
1611
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
1622
1612
                    isinstance(target._format, (RepositoryFormatKnit1)))
1629
1619
        from bzrlib.fetch import KnitRepoFetcher
1630
1620
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1631
1621
               self.source, self.source._format, self.target, self.target._format)
1632
 
        # TODO: jam 20070210 This should be an assert, not a translate
1633
 
        revision_id = osutils.safe_revision_id(revision_id)
1634
1622
        f = KnitRepoFetcher(to_repository=self.target,
1635
1623
                            from_repository=self.source,
1636
1624
                            last_revision=revision_id,
1642
1630
        """See InterRepository.missing_revision_ids()."""
1643
1631
        if revision_id is not None:
1644
1632
            source_ids = self.source.get_ancestry(revision_id)
1645
 
            assert source_ids[0] is None
1646
 
            source_ids.pop(0)
 
1633
            assert source_ids.pop(0) == None
1647
1634
        else:
1648
1635
            source_ids = self.source._all_possible_ids()
1649
1636
        source_ids_set = set(source_ids)
1650
1637
        # source_ids is the worst possible case we may need to pull.
1651
1638
        # now we want to filter source_ids against what we actually
1652
 
        # have in target, but don't try to check for existence where we know
 
1639
        # have in target, but dont try to check for existence where we know
1653
1640
        # we do not have a revision as that would be pointless.
1654
1641
        target_ids = set(self.target._all_possible_ids())
1655
1642
        possibly_present_revisions = target_ids.intersection(source_ids_set)
1667
1654
            # that against the revision records.
1668
1655
            return self.source._eliminate_revisions_not_present(required_topo_revisions)
1669
1656
 
1670
 
 
1671
 
class InterModel1and2(InterRepository):
1672
 
 
1673
 
    @classmethod
1674
 
    def _get_repo_format_to_test(self):
1675
 
        return None
1676
 
 
1677
 
    @staticmethod
1678
 
    def is_compatible(source, target):
1679
 
        if not source.supports_rich_root() and target.supports_rich_root():
1680
 
            return True
1681
 
        else:
1682
 
            return False
1683
 
 
1684
 
    @needs_write_lock
1685
 
    def fetch(self, revision_id=None, pb=None):
1686
 
        """See InterRepository.fetch()."""
1687
 
        from bzrlib.fetch import Model1toKnit2Fetcher
1688
 
        # TODO: jam 20070210 This should be an assert, not a translate
1689
 
        revision_id = osutils.safe_revision_id(revision_id)
1690
 
        f = Model1toKnit2Fetcher(to_repository=self.target,
1691
 
                                 from_repository=self.source,
1692
 
                                 last_revision=revision_id,
1693
 
                                 pb=pb)
1694
 
        return f.count_copied, f.failed_revisions
1695
 
 
1696
 
    @needs_write_lock
1697
 
    def copy_content(self, revision_id=None):
1698
 
        """Make a complete copy of the content in self into destination.
1699
 
        
1700
 
        This is a destructive operation! Do not use it on existing 
1701
 
        repositories.
1702
 
 
1703
 
        :param revision_id: Only copy the content needed to construct
1704
 
                            revision_id and its parents.
1705
 
        """
1706
 
        try:
1707
 
            self.target.set_make_working_trees(self.source.make_working_trees())
1708
 
        except NotImplementedError:
1709
 
            pass
1710
 
        # TODO: jam 20070210 Internal, assert, don't translate
1711
 
        revision_id = osutils.safe_revision_id(revision_id)
1712
 
        # but don't bother fetching if we have the needed data now.
1713
 
        if (revision_id not in (None, _mod_revision.NULL_REVISION) and 
1714
 
            self.target.has_revision(revision_id)):
1715
 
            return
1716
 
        self.target.fetch(self.source, revision_id=revision_id)
1717
 
 
1718
 
 
1719
 
class InterKnit1and2(InterKnitRepo):
1720
 
 
1721
 
    @classmethod
1722
 
    def _get_repo_format_to_test(self):
1723
 
        return None
1724
 
 
1725
 
    @staticmethod
1726
 
    def is_compatible(source, target):
1727
 
        """Be compatible with Knit1 source and Knit3 target"""
1728
 
        from bzrlib.repofmt.knitrepo import RepositoryFormatKnit3
1729
 
        try:
1730
 
            from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1, \
1731
 
                    RepositoryFormatKnit3
1732
 
            return (isinstance(source._format, (RepositoryFormatKnit1)) and
1733
 
                    isinstance(target._format, (RepositoryFormatKnit3)))
1734
 
        except AttributeError:
1735
 
            return False
1736
 
 
1737
 
    @needs_write_lock
1738
 
    def fetch(self, revision_id=None, pb=None):
1739
 
        """See InterRepository.fetch()."""
1740
 
        from bzrlib.fetch import Knit1to2Fetcher
1741
 
        mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1742
 
               self.source, self.source._format, self.target, 
1743
 
               self.target._format)
1744
 
        # TODO: jam 20070210 This should be an assert, not a translate
1745
 
        revision_id = osutils.safe_revision_id(revision_id)
1746
 
        f = Knit1to2Fetcher(to_repository=self.target,
1747
 
                            from_repository=self.source,
1748
 
                            last_revision=revision_id,
1749
 
                            pb=pb)
1750
 
        return f.count_copied, f.failed_revisions
1751
 
 
1752
 
 
1753
 
class InterRemoteRepository(InterRepository):
1754
 
    """Code for converting between RemoteRepository objects.
1755
 
 
1756
 
    This just gets an non-remote repository from the RemoteRepository, and calls
1757
 
    InterRepository.get again.
1758
 
    """
1759
 
 
1760
 
    def __init__(self, source, target):
1761
 
        if isinstance(source, remote.RemoteRepository):
1762
 
            source._ensure_real()
1763
 
            real_source = source._real_repository
1764
 
        else:
1765
 
            real_source = source
1766
 
        if isinstance(target, remote.RemoteRepository):
1767
 
            target._ensure_real()
1768
 
            real_target = target._real_repository
1769
 
        else:
1770
 
            real_target = target
1771
 
        self.real_inter = InterRepository.get(real_source, real_target)
1772
 
 
1773
 
    @staticmethod
1774
 
    def is_compatible(source, target):
1775
 
        if isinstance(source, remote.RemoteRepository):
1776
 
            return True
1777
 
        if isinstance(target, remote.RemoteRepository):
1778
 
            return True
1779
 
        return False
1780
 
 
1781
 
    def copy_content(self, revision_id=None):
1782
 
        self.real_inter.copy_content(revision_id=revision_id)
1783
 
 
1784
 
    def fetch(self, revision_id=None, pb=None):
1785
 
        self.real_inter.fetch(revision_id=revision_id, pb=pb)
1786
 
 
1787
 
    @classmethod
1788
 
    def _get_repo_format_to_test(self):
1789
 
        return None
1790
 
 
1791
 
 
1792
 
InterRepository.register_optimiser(InterSameDataRepository)
1793
1657
InterRepository.register_optimiser(InterWeaveRepo)
1794
1658
InterRepository.register_optimiser(InterKnitRepo)
1795
 
InterRepository.register_optimiser(InterModel1and2)
1796
 
InterRepository.register_optimiser(InterKnit1and2)
1797
 
InterRepository.register_optimiser(InterRemoteRepository)
 
1659
 
 
1660
 
 
1661
class RepositoryTestProviderAdapter(object):
 
1662
    """A tool to generate a suite testing multiple repository formats at once.
 
1663
 
 
1664
    This is done by copying the test once for each transport and injecting
 
1665
    the transport_server, transport_readonly_server, and bzrdir_format and
 
1666
    repository_format classes into each copy. Each copy is also given a new id()
 
1667
    to make it easy to identify.
 
1668
    """
 
1669
 
 
1670
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1671
        self._transport_server = transport_server
 
1672
        self._transport_readonly_server = transport_readonly_server
 
1673
        self._formats = formats
 
1674
    
 
1675
    def adapt(self, test):
 
1676
        result = TestSuite()
 
1677
        for repository_format, bzrdir_format in self._formats:
 
1678
            new_test = deepcopy(test)
 
1679
            new_test.transport_server = self._transport_server
 
1680
            new_test.transport_readonly_server = self._transport_readonly_server
 
1681
            new_test.bzrdir_format = bzrdir_format
 
1682
            new_test.repository_format = repository_format
 
1683
            def make_new_test_id():
 
1684
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
 
1685
                return lambda: new_id
 
1686
            new_test.id = make_new_test_id()
 
1687
            result.addTest(new_test)
 
1688
        return result
 
1689
 
 
1690
 
 
1691
class InterRepositoryTestProviderAdapter(object):
 
1692
    """A tool to generate a suite testing multiple inter repository formats.
 
1693
 
 
1694
    This is done by copying the test once for each interrepo provider and injecting
 
1695
    the transport_server, transport_readonly_server, repository_format and 
 
1696
    repository_to_format classes into each copy.
 
1697
    Each copy is also given a new id() to make it easy to identify.
 
1698
    """
 
1699
 
 
1700
    def __init__(self, transport_server, transport_readonly_server, formats):
 
1701
        self._transport_server = transport_server
 
1702
        self._transport_readonly_server = transport_readonly_server
 
1703
        self._formats = formats
 
1704
    
 
1705
    def adapt(self, test):
 
1706
        result = TestSuite()
 
1707
        for interrepo_class, repository_format, repository_format_to in self._formats:
 
1708
            new_test = deepcopy(test)
 
1709
            new_test.transport_server = self._transport_server
 
1710
            new_test.transport_readonly_server = self._transport_readonly_server
 
1711
            new_test.interrepo_class = interrepo_class
 
1712
            new_test.repository_format = repository_format
 
1713
            new_test.repository_format_to = repository_format_to
 
1714
            def make_new_test_id():
 
1715
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
 
1716
                return lambda: new_id
 
1717
            new_test.id = make_new_test_id()
 
1718
            result.addTest(new_test)
 
1719
        return result
 
1720
 
 
1721
    @staticmethod
 
1722
    def default_test_list():
 
1723
        """Generate the default list of interrepo permutations to test."""
 
1724
        result = []
 
1725
        # test the default InterRepository between format 6 and the current 
 
1726
        # default format.
 
1727
        # XXX: robertc 20060220 reinstate this when there are two supported
 
1728
        # formats which do not have an optimal code path between them.
 
1729
        result.append((InterRepository,
 
1730
                       RepositoryFormat6(),
 
1731
                       RepositoryFormatKnit1()))
 
1732
        for optimiser in InterRepository._optimisers:
 
1733
            result.append((optimiser,
 
1734
                           optimiser._matching_repo_format,
 
1735
                           optimiser._matching_repo_format
 
1736
                           ))
 
1737
        # if there are specific combinations we want to use, we can add them 
 
1738
        # here.
 
1739
        return result
1798
1740
 
1799
1741
 
1800
1742
class CopyConverter(object):
1826
1768
        self.step('Moving repository to repository.backup')
1827
1769
        self.repo_dir.transport.move('repository', 'repository.backup')
1828
1770
        backup_transport =  self.repo_dir.transport.clone('repository.backup')
1829
 
        repo._format.check_conversion_target(self.target_format)
1830
1771
        self.source_repo = repo._format.open(self.repo_dir,
1831
1772
            _found=True,
1832
1773
            _override_transport=backup_transport)
1849
1790
        self.pb.update(message, self.count, self.total)
1850
1791
 
1851
1792
 
1852
 
class CommitBuilder(object):
1853
 
    """Provides an interface to build up a commit.
1854
 
 
1855
 
    This allows describing a tree to be committed without needing to 
1856
 
    know the internals of the format of the repository.
1857
 
    """
1858
 
    
1859
 
    record_root_entry = False
1860
 
    def __init__(self, repository, parents, config, timestamp=None, 
1861
 
                 timezone=None, committer=None, revprops=None, 
1862
 
                 revision_id=None):
1863
 
        """Initiate a CommitBuilder.
1864
 
 
1865
 
        :param repository: Repository to commit to.
1866
 
        :param parents: Revision ids of the parents of the new revision.
1867
 
        :param config: Configuration to use.
1868
 
        :param timestamp: Optional timestamp recorded for commit.
1869
 
        :param timezone: Optional timezone for timestamp.
1870
 
        :param committer: Optional committer to set for commit.
1871
 
        :param revprops: Optional dictionary of revision properties.
1872
 
        :param revision_id: Optional revision id.
1873
 
        """
1874
 
        self._config = config
1875
 
 
1876
 
        if committer is None:
1877
 
            self._committer = self._config.username()
1878
 
        else:
1879
 
            assert isinstance(committer, basestring), type(committer)
1880
 
            self._committer = committer
1881
 
 
1882
 
        self.new_inventory = Inventory(None)
1883
 
        self._new_revision_id = osutils.safe_revision_id(revision_id)
1884
 
        self.parents = parents
1885
 
        self.repository = repository
1886
 
 
1887
 
        self._revprops = {}
1888
 
        if revprops is not None:
1889
 
            self._revprops.update(revprops)
1890
 
 
1891
 
        if timestamp is None:
1892
 
            timestamp = time.time()
1893
 
        # Restrict resolution to 1ms
1894
 
        self._timestamp = round(timestamp, 3)
1895
 
 
1896
 
        if timezone is None:
1897
 
            self._timezone = osutils.local_time_offset()
1898
 
        else:
1899
 
            self._timezone = int(timezone)
1900
 
 
1901
 
        self._generate_revision_if_needed()
1902
 
 
1903
 
    def commit(self, message):
1904
 
        """Make the actual commit.
1905
 
 
1906
 
        :return: The revision id of the recorded revision.
1907
 
        """
1908
 
        rev = _mod_revision.Revision(
1909
 
                       timestamp=self._timestamp,
1910
 
                       timezone=self._timezone,
1911
 
                       committer=self._committer,
1912
 
                       message=message,
1913
 
                       inventory_sha1=self.inv_sha1,
1914
 
                       revision_id=self._new_revision_id,
1915
 
                       properties=self._revprops)
1916
 
        rev.parent_ids = self.parents
1917
 
        self.repository.add_revision(self._new_revision_id, rev, 
1918
 
            self.new_inventory, self._config)
1919
 
        return self._new_revision_id
1920
 
 
1921
 
    def revision_tree(self):
1922
 
        """Return the tree that was just committed.
1923
 
 
1924
 
        After calling commit() this can be called to get a RevisionTree
1925
 
        representing the newly committed tree. This is preferred to
1926
 
        calling Repository.revision_tree() because that may require
1927
 
        deserializing the inventory, while we already have a copy in
1928
 
        memory.
1929
 
        """
1930
 
        return RevisionTree(self.repository, self.new_inventory,
1931
 
                            self._new_revision_id)
1932
 
 
1933
 
    def finish_inventory(self):
1934
 
        """Tell the builder that the inventory is finished."""
1935
 
        if self.new_inventory.root is None:
1936
 
            symbol_versioning.warn('Root entry should be supplied to'
1937
 
                ' record_entry_contents, as of bzr 0.10.',
1938
 
                 DeprecationWarning, stacklevel=2)
1939
 
            self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
1940
 
        self.new_inventory.revision_id = self._new_revision_id
1941
 
        self.inv_sha1 = self.repository.add_inventory(
1942
 
            self._new_revision_id,
1943
 
            self.new_inventory,
1944
 
            self.parents
1945
 
            )
1946
 
 
1947
 
    def _gen_revision_id(self):
1948
 
        """Return new revision-id."""
1949
 
        return generate_ids.gen_revision_id(self._config.username(),
1950
 
                                            self._timestamp)
1951
 
 
1952
 
    def _generate_revision_if_needed(self):
1953
 
        """Create a revision id if None was supplied.
1954
 
        
1955
 
        If the repository can not support user-specified revision ids
1956
 
        they should override this function and raise CannotSetRevisionId
1957
 
        if _new_revision_id is not None.
1958
 
 
1959
 
        :raises: CannotSetRevisionId
1960
 
        """
1961
 
        if self._new_revision_id is None:
1962
 
            self._new_revision_id = self._gen_revision_id()
1963
 
 
1964
 
    def record_entry_contents(self, ie, parent_invs, path, tree):
1965
 
        """Record the content of ie from tree into the commit if needed.
1966
 
 
1967
 
        Side effect: sets ie.revision when unchanged
1968
 
 
1969
 
        :param ie: An inventory entry present in the commit.
1970
 
        :param parent_invs: The inventories of the parent revisions of the
1971
 
            commit.
1972
 
        :param path: The path the entry is at in the tree.
1973
 
        :param tree: The tree which contains this entry and should be used to 
1974
 
        obtain content.
1975
 
        """
1976
 
        if self.new_inventory.root is None and ie.parent_id is not None:
1977
 
            symbol_versioning.warn('Root entry should be supplied to'
1978
 
                ' record_entry_contents, as of bzr 0.10.',
1979
 
                 DeprecationWarning, stacklevel=2)
1980
 
            self.record_entry_contents(tree.inventory.root.copy(), parent_invs,
1981
 
                                       '', tree)
1982
 
        self.new_inventory.add(ie)
1983
 
 
1984
 
        # ie.revision is always None if the InventoryEntry is considered
1985
 
        # for committing. ie.snapshot will record the correct revision 
1986
 
        # which may be the sole parent if it is untouched.
1987
 
        if ie.revision is not None:
1988
 
            return
1989
 
 
1990
 
        # In this revision format, root entries have no knit or weave
1991
 
        if ie is self.new_inventory.root:
1992
 
            # When serializing out to disk and back in
1993
 
            # root.revision is always _new_revision_id
1994
 
            ie.revision = self._new_revision_id
1995
 
            return
1996
 
        previous_entries = ie.find_previous_heads(
1997
 
            parent_invs,
1998
 
            self.repository.weave_store,
1999
 
            self.repository.get_transaction())
2000
 
        # we are creating a new revision for ie in the history store
2001
 
        # and inventory.
2002
 
        ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
2003
 
 
2004
 
    def modified_directory(self, file_id, file_parents):
2005
 
        """Record the presence of a symbolic link.
2006
 
 
2007
 
        :param file_id: The file_id of the link to record.
2008
 
        :param file_parents: The per-file parent revision ids.
2009
 
        """
2010
 
        self._add_text_to_weave(file_id, [], file_parents.keys())
2011
 
 
2012
 
    def modified_reference(self, file_id, file_parents):
2013
 
        """Record the modification of a reference.
2014
 
 
2015
 
        :param file_id: The file_id of the link to record.
2016
 
        :param file_parents: The per-file parent revision ids.
2017
 
        """
2018
 
        self._add_text_to_weave(file_id, [], file_parents.keys())
2019
 
    
2020
 
    def modified_file_text(self, file_id, file_parents,
2021
 
                           get_content_byte_lines, text_sha1=None,
2022
 
                           text_size=None):
2023
 
        """Record the text of file file_id
2024
 
 
2025
 
        :param file_id: The file_id of the file to record the text of.
2026
 
        :param file_parents: The per-file parent revision ids.
2027
 
        :param get_content_byte_lines: A callable which will return the byte
2028
 
            lines for the file.
2029
 
        :param text_sha1: Optional SHA1 of the file contents.
2030
 
        :param text_size: Optional size of the file contents.
2031
 
        """
2032
 
        # mutter('storing text of file {%s} in revision {%s} into %r',
2033
 
        #        file_id, self._new_revision_id, self.repository.weave_store)
2034
 
        # special case to avoid diffing on renames or 
2035
 
        # reparenting
2036
 
        if (len(file_parents) == 1
2037
 
            and text_sha1 == file_parents.values()[0].text_sha1
2038
 
            and text_size == file_parents.values()[0].text_size):
2039
 
            previous_ie = file_parents.values()[0]
2040
 
            versionedfile = self.repository.weave_store.get_weave(file_id, 
2041
 
                self.repository.get_transaction())
2042
 
            versionedfile.clone_text(self._new_revision_id, 
2043
 
                previous_ie.revision, file_parents.keys())
2044
 
            return text_sha1, text_size
2045
 
        else:
2046
 
            new_lines = get_content_byte_lines()
2047
 
            # TODO: Rather than invoking sha_strings here, _add_text_to_weave
2048
 
            # should return the SHA1 and size
2049
 
            self._add_text_to_weave(file_id, new_lines, file_parents.keys())
2050
 
            return osutils.sha_strings(new_lines), \
2051
 
                sum(map(len, new_lines))
2052
 
 
2053
 
    def modified_link(self, file_id, file_parents, link_target):
2054
 
        """Record the presence of a symbolic link.
2055
 
 
2056
 
        :param file_id: The file_id of the link to record.
2057
 
        :param file_parents: The per-file parent revision ids.
2058
 
        :param link_target: Target location of this link.
2059
 
        """
2060
 
        self._add_text_to_weave(file_id, [], file_parents.keys())
2061
 
 
2062
 
    def _add_text_to_weave(self, file_id, new_lines, parents):
2063
 
        versionedfile = self.repository.weave_store.get_weave_or_empty(
2064
 
            file_id, self.repository.get_transaction())
2065
 
        versionedfile.add_lines(self._new_revision_id, parents, new_lines)
2066
 
        versionedfile.clear_cache()
2067
 
 
2068
 
 
2069
 
class _CommitBuilder(CommitBuilder):
2070
 
    """Temporary class so old CommitBuilders are detected properly
2071
 
    
2072
 
    Note: CommitBuilder works whether or not root entry is recorded.
2073
 
    """
2074
 
 
2075
 
    record_root_entry = True
2076
 
 
2077
 
 
2078
 
class RootCommitBuilder(CommitBuilder):
2079
 
    """This commitbuilder actually records the root id"""
2080
 
    
2081
 
    record_root_entry = True
2082
 
 
2083
 
    def record_entry_contents(self, ie, parent_invs, path, tree):
2084
 
        """Record the content of ie from tree into the commit if needed.
2085
 
 
2086
 
        Side effect: sets ie.revision when unchanged
2087
 
 
2088
 
        :param ie: An inventory entry present in the commit.
2089
 
        :param parent_invs: The inventories of the parent revisions of the
2090
 
            commit.
2091
 
        :param path: The path the entry is at in the tree.
2092
 
        :param tree: The tree which contains this entry and should be used to 
2093
 
        obtain content.
2094
 
        """
2095
 
        assert self.new_inventory.root is not None or ie.parent_id is None
2096
 
        self.new_inventory.add(ie)
2097
 
 
2098
 
        # ie.revision is always None if the InventoryEntry is considered
2099
 
        # for committing. ie.snapshot will record the correct revision 
2100
 
        # which may be the sole parent if it is untouched.
2101
 
        if ie.revision is not None:
2102
 
            return
2103
 
 
2104
 
        previous_entries = ie.find_previous_heads(
2105
 
            parent_invs,
2106
 
            self.repository.weave_store,
2107
 
            self.repository.get_transaction())
2108
 
        # we are creating a new revision for ie in the history store
2109
 
        # and inventory.
2110
 
        ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
2111
 
 
2112
 
 
2113
 
_unescape_map = {
2114
 
    'apos':"'",
2115
 
    'quot':'"',
2116
 
    'amp':'&',
2117
 
    'lt':'<',
2118
 
    'gt':'>'
2119
 
}
2120
 
 
2121
 
 
2122
 
def _unescaper(match, _map=_unescape_map):
2123
 
    code = match.group(1)
2124
 
    try:
2125
 
        return _map[code]
2126
 
    except KeyError:
2127
 
        if not code.startswith('#'):
2128
 
            raise
2129
 
        return unichr(int(code[1:])).encode('utf8')
2130
 
 
2131
 
 
2132
 
_unescape_re = None
2133
 
 
2134
 
 
 
1793
# Copied from xml.sax.saxutils
2135
1794
def _unescape_xml(data):
2136
 
    """Unescape predefined XML entities in a string of data."""
2137
 
    global _unescape_re
2138
 
    if _unescape_re is None:
2139
 
        _unescape_re = re.compile('\&([^;]*);')
2140
 
    return _unescape_re.sub(_unescaper, data)
 
1795
    """Unescape &amp;, &lt;, and &gt; in a string of data.
 
1796
    """
 
1797
    data = data.replace("&lt;", "<")
 
1798
    data = data.replace("&gt;", ">")
 
1799
    # must do ampersand last
 
1800
    return data.replace("&amp;", "&")