« back to all changes in this revision
Viewing changes to bzrlib/repository.py
- browse files at revision 2208.4.4
- compare with another revision
- compare with revision 1717
- download diff
- download tarball
- view history from revision 2208.4.4
- Committer: Andrew Bennetts
- Date: 2007-04-26 06:19:07 UTC
- mfrom: (2459 +trunk)
- mto: (2432.3.7 hpss-vfs-fallback)
- mto: This revision was merged to the branch mainline in revision 2463.
- Revision ID: andrew.bennetts@canonical.com-20070426061907-ipn74twdz1gmz52i
Merge bzr.dev.
- files added:
- bzrlib/breakin.py
- bzrlib/repofmt
- bzrlib/smart
- bzrlib/tests/per_lock
- man1
- files removed:
- NEWS.developers
- files renamed:
- bzrlib/transport/smart.py => bzrlib/transport/remote.py
- bzrlib/win32console.py => bzrlib/win32utils.py
- files modified:
- .bzrignore
- setup.py *
added
removed
bzrlib/repository.py
1
# Copyright (C) 2005, 2006 Canonical Ltd
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
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
18
18
19
19
from bzrlib.lazy_import import lazy_import
20
20
lazy_import(globals(), """
21
from binascii import hexlify
22
from copy import deepcopy
23
21
import re
24
22
import time
25
23
import unittest
27
25
from bzrlib import (
28
26
bzrdir,
29
27
check,
30
delta,
31
28
errors,
32
29
generate_ids,
33
30
gpg,
34
31
graph,
35
knit,
36
32
lazy_regex,
37
33
lockable_files,
38
34
lockdir,
39
35
osutils,
36
registry,
37
remote,
40
38
revision as _mod_revision,
41
39
symbol_versioning,
42
40
transactions,
43
41
ui,
44
weave,
45
weavefile,
46
xml5,
47
xml6,
48
)
49
from bzrlib.osutils import (
50
rand_bytes,
51
compact_date,
52
local_time_offset,
53
42
)
54
43
from bzrlib.revisiontree import RevisionTree
55
44
from bzrlib.store.versioned import VersionedFileStore
56
45
from bzrlib.store.text import TextStore
57
46
from bzrlib.testament import Testament
47
58
48
""")
59
49
60
50
from bzrlib.decorators import needs_read_lock, needs_write_lock
71
61
_deprecation_warning_done = False
72
62
73
63
64
######################################################################
65
# Repositories
66
74
67
class Repository(object):
75
68
"""Repository holding history for one or more branches.
76
69
89
82
)
90
83
91
84
@needs_write_lock
92
def add_inventory(self, revid, inv, parents):
93
"""Add the inventory inv to the repository as revid.
85
def add_inventory(self, revision_id, inv, parents):
86
"""Add the inventory inv to the repository as revision_id.
94
87
95
:param parents: The revision ids of the parents that revid
88
:param parents: The revision ids of the parents that revision_id
96
89
is known to have and are in the repository already.
97
90
98
91
returns the sha1 of the serialized inventory.
99
92
"""
100
assert inv.revision_id is None or inv.revision_id == revid, \
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, \
101
96
"Mismatch between inventory revision" \
102
" id and insertion revid (%r, %r)" % (inv.revision_id, revid)
97
" id and insertion revid (%r, %r)" % (inv.revision_id, revision_id)
103
98
assert inv.root is not None
104
99
inv_text = self.serialise_inventory(inv)
105
100
inv_sha1 = osutils.sha_string(inv_text)
106
101
inv_vf = self.control_weaves.get_weave('inventory',
107
102
self.get_transaction())
108
self._inventory_add_lines(inv_vf, revid, parents, osutils.split_lines(inv_text))
103
self._inventory_add_lines(inv_vf, revision_id, parents,
104
osutils.split_lines(inv_text))
109
105
return inv_sha1
110
106
111
def _inventory_add_lines(self, inv_vf, revid, parents, lines):
107
def _inventory_add_lines(self, inv_vf, revision_id, parents, lines):
112
108
final_parents = []
113
109
for parent in parents:
114
110
if parent in inv_vf:
115
111
final_parents.append(parent)
116
112
117
inv_vf.add_lines(revid, final_parents, lines)
113
inv_vf.add_lines(revision_id, final_parents, lines)
118
114
119
115
@needs_write_lock
120
def add_revision(self, rev_id, rev, inv=None, config=None):
121
"""Add rev to the revision store as rev_id.
116
def add_revision(self, revision_id, rev, inv=None, config=None):
117
"""Add rev to the revision store as revision_id.
122
118
123
:param rev_id: the revision id to use.
119
:param revision_id: the revision id to use.
124
120
:param rev: The revision object.
125
121
:param inv: The inventory for the revision. if None, it will be looked
126
122
up in the inventory storer
128
124
If supplied its signature_needed method will be used
129
125
to determine if a signature should be made.
130
126
"""
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
131
if config is not None and config.signature_needed():
132
132
if inv is None:
133
inv = self.get_inventory(rev_id)
133
inv = self.get_inventory(revision_id)
134
134
plaintext = Testament(rev, inv).as_short_text()
135
135
self.store_revision_signature(
136
gpg.GPGStrategy(config), plaintext, rev_id)
137
if not rev_id in self.get_inventory_weave():
136
gpg.GPGStrategy(config), plaintext, revision_id)
137
if not revision_id in self.get_inventory_weave():
138
138
if inv is None:
139
raise errors.WeaveRevisionNotPresent(rev_id,
139
raise errors.WeaveRevisionNotPresent(revision_id,
140
140
self.get_inventory_weave())
141
141
else:
142
142
# yes, this is not suitable for adding with ghosts.
143
self.add_inventory(rev_id, inv, rev.parent_ids)
143
self.add_inventory(revision_id, inv, rev.parent_ids)
144
144
self._revision_store.add_revision(rev, self.get_transaction())
145
145
146
146
@needs_read_lock
168
168
if self._revision_store.text_store.listable():
169
169
return self._revision_store.all_revision_ids(self.get_transaction())
170
170
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)
171
174
return self._eliminate_revisions_not_present(result)
172
175
173
176
def break_lock(self):
221
224
# TODO: make sure to construct the right store classes, etc, depending
222
225
# on whether escaping is required.
223
226
self._warn_if_deprecated()
224
self._serializer = xml5.serializer_v5
225
227
226
228
def __repr__(self):
227
229
return '%s(%r)' % (self.__class__.__name__,
230
232
def is_locked(self):
231
233
return self.control_files.is_locked()
232
234
233
def lock_write(self):
234
self.control_files.lock_write()
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)
235
253
236
254
def lock_read(self):
237
255
self.control_files.lock_read()
239
257
def get_physical_lock_status(self):
240
258
return self.control_files.get_physical_lock_status()
241
259
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
242
326
@needs_read_lock
243
327
def missing_revision_ids(self, other, revision_id=None):
244
328
"""Return the revision ids that other has that this does not.
247
331
248
332
revision_id: only return revision ids included by revision_id.
249
333
"""
334
revision_id = osutils.safe_revision_id(revision_id)
250
335
return InterRepository.get(other, self).missing_revision_ids(revision_id)
251
336
252
337
@staticmethod
259
344
control = bzrdir.BzrDir.open(base)
260
345
return control.open_repository()
261
346
262
def copy_content_into(self, destination, revision_id=None, basis=None):
347
def copy_content_into(self, destination, revision_id=None):
263
348
"""Make a complete copy of the content in self into destination.
264
349
265
350
This is a destructive operation! Do not use it on existing
266
351
repositories.
267
352
"""
268
return InterRepository.get(self, destination).copy_content(revision_id, basis)
353
revision_id = osutils.safe_revision_id(revision_id)
354
return InterRepository.get(self, destination).copy_content(revision_id)
269
355
270
356
def fetch(self, source, revision_id=None, pb=None):
271
357
"""Fetch the content required to construct revision_id from source.
272
358
273
359
If revision_id is None all content is copied.
274
360
"""
275
return InterRepository.get(source, self).fetch(revision_id=revision_id,
276
pb=pb)
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)
277
367
278
368
def get_commit_builder(self, branch, parents, config, timestamp=None,
279
369
timezone=None, committer=None, revprops=None,
289
379
:param revprops: Optional dictionary of revision properties.
290
380
:param revision_id: Optional revision id.
291
381
"""
382
revision_id = osutils.safe_revision_id(revision_id)
292
383
return _CommitBuilder(self, parents, config, timestamp, timezone,
293
384
committer, revprops, revision_id)
294
385
296
387
self.control_files.unlock()
297
388
298
389
@needs_read_lock
299
def clone(self, a_bzrdir, revision_id=None, basis=None):
390
def clone(self, a_bzrdir, revision_id=None):
300
391
"""Clone this repository into a_bzrdir using the current format.
301
392
302
393
Currently no check is made that the format of this repository and
303
394
the bzrdir format are compatible. FIXME RBC 20060201.
395
396
:return: The newly created destination repository.
304
397
"""
305
398
if not isinstance(a_bzrdir._format, self.bzrdir._format.__class__):
306
399
# use target default format.
307
result = a_bzrdir.create_repository()
308
# FIXME RBC 20060209 split out the repository type to avoid this check ?
309
elif isinstance(a_bzrdir._format,
310
(bzrdir.BzrDirFormat4,
311
bzrdir.BzrDirFormat5,
312
bzrdir.BzrDirFormat6)):
313
result = a_bzrdir.open_repository()
400
dest_repo = a_bzrdir.create_repository()
314
401
else:
315
result = self._format.initialize(a_bzrdir, shared=self.is_shared())
316
self.copy_content_into(result, revision_id, basis)
317
return result
402
# Most control formats need the repository to be specifically
403
# created, but on some old all-in-one formats it's not needed
404
try:
405
dest_repo = self._format.initialize(a_bzrdir, shared=self.is_shared())
406
except errors.UninitializableFormat:
407
dest_repo = a_bzrdir.open_repository()
408
self.copy_content_into(dest_repo, revision_id)
409
return dest_repo
318
410
319
411
@needs_read_lock
320
412
def has_revision(self, revision_id):
321
413
"""True if this repository has a copy of the revision."""
414
revision_id = osutils.safe_revision_id(revision_id)
322
415
return self._revision_store.has_revision_id(revision_id,
323
416
self.get_transaction())
324
417
334
427
if not revision_id or not isinstance(revision_id, basestring):
335
428
raise errors.InvalidRevisionId(revision_id=revision_id,
336
429
branch=self)
337
return self._revision_store.get_revisions([revision_id],
338
self.get_transaction())[0]
430
return self.get_revisions([revision_id])[0]
431
339
432
@needs_read_lock
340
433
def get_revisions(self, revision_ids):
341
return self._revision_store.get_revisions(revision_ids,
434
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
435
revs = self._revision_store.get_revisions(revision_ids,
342
436
self.get_transaction())
437
for rev in revs:
438
assert not isinstance(rev.revision_id, unicode)
439
for parent_id in rev.parent_ids:
440
assert not isinstance(parent_id, unicode)
441
return revs
343
442
344
443
@needs_read_lock
345
444
def get_revision_xml(self, revision_id):
346
rev = self.get_revision(revision_id)
445
# TODO: jam 20070210 This shouldn't be necessary since get_revision
446
# would have already do it.
447
# TODO: jam 20070210 Just use _serializer.write_revision_to_string()
448
revision_id = osutils.safe_revision_id(revision_id)
449
rev = self.get_revision(revision_id)
347
450
rev_tmp = StringIO()
348
451
# the current serializer..
349
452
self._revision_store._serializer.write_revision(rev, rev_tmp)
353
456
@needs_read_lock
354
457
def get_revision(self, revision_id):
355
458
"""Return the Revision object for a named revision"""
459
# TODO: jam 20070210 get_revision_reconcile should do this for us
460
revision_id = osutils.safe_revision_id(revision_id)
356
461
r = self.get_revision_reconcile(revision_id)
357
462
# weave corruption can lead to absent revision markers that should be
358
463
# present.
414
519
415
520
@needs_write_lock
416
521
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
522
revision_id = osutils.safe_revision_id(revision_id)
417
523
signature = gpg_strategy.sign(plaintext)
418
524
self._revision_store.add_revision_signature_text(revision_id,
419
525
signature,
430
536
assert self._serializer.support_altered_by_hack, \
431
537
("fileids_altered_by_revision_ids only supported for branches "
432
538
"which store inventory as unnested xml, not on %r" % self)
433
selected_revision_ids = set(revision_ids)
539
selected_revision_ids = set(osutils.safe_revision_id(r)
540
for r in revision_ids)
434
541
w = self.get_inventory_weave()
435
542
result = {}
436
543
445
552
unescape_revid_cache = {}
446
553
unescape_fileid_cache = {}
447
554
555
# jam 20061218 In a big fetch, this handles hundreds of thousands
556
# of lines, so it has had a lot of inlining and optimizing done.
557
# Sorry that it is a little bit messy.
448
558
# Move several functions to be local variables, since this is a long
449
559
# running loop.
450
560
search = self._file_ids_altered_regex.search
451
unescape = _unescape_xml_cached
561
unescape = _unescape_xml
452
562
setdefault = result.setdefault
453
563
pb = ui.ui_factory.nested_progress_bar()
454
564
try:
457
567
match = search(line)
458
568
if match is None:
459
569
continue
570
# One call to match.group() returning multiple items is quite a
571
# bit faster than 2 calls to match.group() each returning 1
460
572
file_id, revision_id = match.group('file_id', 'revision_id')
461
revision_id = unescape(revision_id, unescape_revid_cache)
573
574
# Inlining the cache lookups helps a lot when you make 170,000
575
# lines and 350k ids, versus 8.4 unique ids.
576
# Using a cache helps in 2 ways:
577
# 1) Avoids unnecessary decoding calls
578
# 2) Re-uses cached strings, which helps in future set and
579
# equality checks.
580
# (2) is enough that removing encoding entirely along with
581
# the cache (so we are using plain strings) results in no
582
# performance improvement.
583
try:
584
revision_id = unescape_revid_cache[revision_id]
585
except KeyError:
586
unescaped = unescape(revision_id)
587
unescape_revid_cache[revision_id] = unescaped
588
revision_id = unescaped
589
462
590
if revision_id in selected_revision_ids:
463
file_id = unescape(file_id, unescape_fileid_cache)
591
try:
592
file_id = unescape_fileid_cache[file_id]
593
except KeyError:
594
unescaped = unescape(file_id)
595
unescape_fileid_cache[file_id] = unescaped
596
file_id = unescaped
464
597
setdefault(file_id, set()).add(revision_id)
465
598
finally:
466
599
pb.finished()
474
607
@needs_read_lock
475
608
def get_inventory(self, revision_id):
476
609
"""Get Inventory object by hash."""
610
# TODO: jam 20070210 Technically we don't need to sanitize, since all
611
# called functions must sanitize.
612
revision_id = osutils.safe_revision_id(revision_id)
477
613
return self.deserialise_inventory(
478
614
revision_id, self.get_inventory_xml(revision_id))
479
615
483
619
:param revision_id: The expected revision id of the inventory.
484
620
:param xml: A serialised inventory.
485
621
"""
622
revision_id = osutils.safe_revision_id(revision_id)
486
623
result = self._serializer.read_inventory_from_string(xml)
487
624
result.root.revision = revision_id
488
625
return result
493
630
@needs_read_lock
494
631
def get_inventory_xml(self, revision_id):
495
632
"""Get inventory XML as a file object."""
633
revision_id = osutils.safe_revision_id(revision_id)
496
634
try:
497
assert isinstance(revision_id, basestring), type(revision_id)
635
assert isinstance(revision_id, str), type(revision_id)
498
636
iw = self.get_inventory_weave()
499
637
return iw.get_text(revision_id)
500
638
except IndexError:
504
642
def get_inventory_sha1(self, revision_id):
505
643
"""Return the sha1 hash of the inventory entry
506
644
"""
645
# TODO: jam 20070210 Shouldn't this be deprecated / removed?
646
revision_id = osutils.safe_revision_id(revision_id)
507
647
return self.get_revision(revision_id).inventory_sha1
508
648
509
649
@needs_read_lock
518
658
# special case NULL_REVISION
519
659
if revision_id == _mod_revision.NULL_REVISION:
520
660
return {}
661
revision_id = osutils.safe_revision_id(revision_id)
521
662
a_weave = self.get_inventory_weave()
522
663
all_revisions = self._eliminate_revisions_not_present(
523
664
a_weave.versions())
551
692
pending = set(self.all_revision_ids())
552
693
required = set([])
553
694
else:
554
pending = set(revision_ids)
695
pending = set(osutils.safe_revision_id(r) for r in revision_ids)
555
696
# special case NULL_REVISION
556
697
if _mod_revision.NULL_REVISION in pending:
557
698
pending.remove(_mod_revision.NULL_REVISION)
577
718
done.add(revision_id)
578
719
return result
579
720
721
def _get_history_vf(self):
722
"""Get a versionedfile whose history graph reflects all revisions.
723
724
For weave repositories, this is the inventory weave.
725
"""
726
return self.get_inventory_weave()
727
728
def iter_reverse_revision_history(self, revision_id):
729
"""Iterate backwards through revision ids in the lefthand history
730
731
:param revision_id: The revision id to start with. All its lefthand
732
ancestors will be traversed.
733
"""
734
revision_id = osutils.safe_revision_id(revision_id)
735
if revision_id in (None, _mod_revision.NULL_REVISION):
736
return
737
next_id = revision_id
738
versionedfile = self._get_history_vf()
739
while True:
740
yield next_id
741
parents = versionedfile.get_parents(next_id)
742
if len(parents) == 0:
743
return
744
else:
745
next_id = parents[0]
746
580
747
@needs_read_lock
581
748
def get_revision_inventory(self, revision_id):
582
749
"""Return inventory of a past revision."""
618
785
return RevisionTree(self, Inventory(root_id=None),
619
786
_mod_revision.NULL_REVISION)
620
787
else:
788
revision_id = osutils.safe_revision_id(revision_id)
621
789
inv = self.get_revision_inventory(revision_id)
622
790
return RevisionTree(self, inv, revision_id)
623
791
645
813
"""
646
814
if revision_id is None:
647
815
return [None]
816
revision_id = osutils.safe_revision_id(revision_id)
648
817
if not self.has_revision(revision_id):
649
818
raise errors.NoSuchRevision(self, revision_id)
650
819
w = self.get_inventory_weave()
659
828
- it writes to stdout, it assumes that that is valid etc. Fix
660
829
by creating a new more flexible convenience function.
661
830
"""
831
revision_id = osutils.safe_revision_id(revision_id)
662
832
tree = self.revision_tree(revision_id)
663
833
# use inventory as it was in that revision
664
834
file_id = tree.inventory.path2id(file)
672
842
def get_transaction(self):
673
843
return self.control_files.get_transaction()
674
844
675
def revision_parents(self, revid):
676
return self.get_inventory_weave().parent_names(revid)
845
def revision_parents(self, revision_id):
846
revision_id = osutils.safe_revision_id(revision_id)
847
return self.get_inventory_weave().parent_names(revision_id)
677
848
678
849
@needs_write_lock
679
850
def set_make_working_trees(self, new_value):
693
864
694
865
@needs_write_lock
695
866
def sign_revision(self, revision_id, gpg_strategy):
867
revision_id = osutils.safe_revision_id(revision_id)
696
868
plaintext = Testament.from_revision(self, revision_id).as_short_text()
697
869
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
698
870
699
871
@needs_read_lock
700
872
def has_signature_for_revision_id(self, revision_id):
701
873
"""Query for a revision signature for revision_id in the repository."""
874
revision_id = osutils.safe_revision_id(revision_id)
702
875
return self._revision_store.has_signature(revision_id,
703
876
self.get_transaction())
704
877
705
878
@needs_read_lock
706
879
def get_signature_text(self, revision_id):
707
880
"""Return the text for a signature."""
881
revision_id = osutils.safe_revision_id(revision_id)
708
882
return self._revision_store.get_signature_text(revision_id,
709
883
self.get_transaction())
710
884
720
894
if not revision_ids:
721
895
raise ValueError("revision_ids must be non-empty in %s.check"
722
896
% (self,))
897
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
723
898
return self._check(revision_ids)
724
899
725
900
def _check(self, revision_ids):
748
923
revision_id.encode('ascii')
749
924
except UnicodeEncodeError:
750
925
raise errors.NonAsciiRevisionId(method, self)
751
752
753
class AllInOneRepository(Repository):
754
"""Legacy support - the repository behaviour for all-in-one branches."""
755
756
def __init__(self, _format, a_bzrdir, _revision_store, control_store, text_store):
757
# we reuse one control files instance.
758
dir_mode = a_bzrdir._control_files._dir_mode
759
file_mode = a_bzrdir._control_files._file_mode
760
761
def get_store(name, compressed=True, prefixed=False):
762
# FIXME: This approach of assuming stores are all entirely compressed
763
# or entirely uncompressed is tidy, but breaks upgrade from
764
# some existing branches where there's a mixture; we probably
765
# still want the option to look for both.
766
relpath = a_bzrdir._control_files._escape(name)
767
store = TextStore(a_bzrdir._control_files._transport.clone(relpath),
768
prefixed=prefixed, compressed=compressed,
769
dir_mode=dir_mode,
770
file_mode=file_mode)
771
#if self._transport.should_cache():
772
# cache_path = os.path.join(self.cache_root, name)
773
# os.mkdir(cache_path)
774
# store = bzrlib.store.CachedStore(store, cache_path)
775
return store
776
777
# not broken out yet because the controlweaves|inventory_store
778
# and text_store | weave_store bits are still different.
779
if isinstance(_format, RepositoryFormat4):
780
# cannot remove these - there is still no consistent api
781
# which allows access to this old info.
782
self.inventory_store = get_store('inventory-store')
783
text_store = get_store('text-store')
784
super(AllInOneRepository, self).__init__(_format, a_bzrdir, a_bzrdir._control_files, _revision_store, control_store, text_store)
785
786
def get_commit_builder(self, branch, parents, config, timestamp=None,
787
timezone=None, committer=None, revprops=None,
788
revision_id=None):
789
self._check_ascii_revisionid(revision_id, self.get_commit_builder)
790
return Repository.get_commit_builder(self, branch, parents, config,
791
timestamp, timezone, committer, revprops, revision_id)
792
793
@needs_read_lock
794
def is_shared(self):
795
"""AllInOne repositories cannot be shared."""
796
return False
797
798
@needs_write_lock
799
def set_make_working_trees(self, new_value):
800
"""Set the policy flag for making working trees when creating branches.
801
802
This only applies to branches that use this repository.
803
804
The default is 'True'.
805
:param new_value: True to restore the default, False to disable making
806
working trees.
807
"""
808
raise NotImplementedError(self.set_make_working_trees)
809
810
def make_working_trees(self):
811
"""Returns the policy for making working trees on new branches."""
812
return True
926
else:
927
try:
928
revision_id.decode('ascii')
929
except UnicodeDecodeError:
930
raise errors.NonAsciiRevisionId(method, self)
931
932
933
934
# remove these delegates a while after bzr 0.15
935
def __make_delegated(name, from_module):
936
def _deprecated_repository_forwarder():
937
symbol_versioning.warn('%s moved to %s in bzr 0.15'
938
% (name, from_module),
939
DeprecationWarning,
940
stacklevel=2)
941
m = __import__(from_module, globals(), locals(), [name])
942
try:
943
return getattr(m, name)
944
except AttributeError:
945
raise AttributeError('module %s has no name %s'
946
% (m, name))
947
globals()[name] = _deprecated_repository_forwarder
948
949
for _name in [
950
'AllInOneRepository',
951
'WeaveMetaDirRepository',
952
'PreSplitOutRepositoryFormat',
953
'RepositoryFormat4',
954
'RepositoryFormat5',
955
'RepositoryFormat6',
956
'RepositoryFormat7',
957
]:
958
__make_delegated(_name, 'bzrlib.repofmt.weaverepo')
959
960
for _name in [
961
'KnitRepository',
962
'RepositoryFormatKnit',
963
'RepositoryFormatKnit1',
964
]:
965
__make_delegated(_name, 'bzrlib.repofmt.knitrepo')
813
966
814
967
815
968
def install_revision(repository, rev, revision_tree):
901
1054
return not self.control_files._transport.has('no-working-trees')
902
1055
903
1056
904
class WeaveMetaDirRepository(MetaDirRepository):
905
"""A subclass of MetaDirRepository to set weave specific policy."""
906
907
def get_commit_builder(self, branch, parents, config, timestamp=None,
908
timezone=None, committer=None, revprops=None,
909
revision_id=None):
910
self._check_ascii_revisionid(revision_id, self.get_commit_builder)
911
return MetaDirRepository.get_commit_builder(self, branch, parents,
912
config, timestamp, timezone, committer, revprops, revision_id)
913
914
915
class KnitRepository(MetaDirRepository):
916
"""Knit format repository."""
917
918
def _warn_if_deprecated(self):
919
# This class isn't deprecated
920
pass
921
922
def _inventory_add_lines(self, inv_vf, revid, parents, lines):
923
inv_vf.add_lines_with_ghosts(revid, parents, lines)
924
925
@needs_read_lock
926
def _all_revision_ids(self):
927
"""See Repository.all_revision_ids()."""
928
# Knits get the revision graph from the index of the revision knit, so
929
# it's always possible even if they're on an unlistable transport.
930
return self._revision_store.all_revision_ids(self.get_transaction())
931
932
def fileid_involved_between_revs(self, from_revid, to_revid):
933
"""Find file_id(s) which are involved in the changes between revisions.
934
935
This determines the set of revisions which are involved, and then
936
finds all file ids affected by those revisions.
937
"""
938
vf = self._get_revision_vf()
939
from_set = set(vf.get_ancestry(from_revid))
940
to_set = set(vf.get_ancestry(to_revid))
941
changed = to_set.difference(from_set)
942
return self._fileid_involved_by_set(changed)
943
944
def fileid_involved(self, last_revid=None):
945
"""Find all file_ids modified in the ancestry of last_revid.
946
947
:param last_revid: If None, last_revision() will be used.
948
"""
949
if not last_revid:
950
changed = set(self.all_revision_ids())
951
else:
952
changed = set(self.get_ancestry(last_revid))
953
if None in changed:
954
changed.remove(None)
955
return self._fileid_involved_by_set(changed)
956
957
@needs_read_lock
958
def get_ancestry(self, revision_id):
959
"""Return a list of revision-ids integrated by a revision.
960
961
This is topologically sorted.
962
"""
963
if revision_id is None:
964
return [None]
965
vf = self._get_revision_vf()
966
try:
967
return [None] + vf.get_ancestry(revision_id)
968
except errors.RevisionNotPresent:
969
raise errors.NoSuchRevision(self, revision_id)
970
971
@needs_read_lock
972
def get_revision(self, revision_id):
973
"""Return the Revision object for a named revision"""
974
return self.get_revision_reconcile(revision_id)
975
976
@needs_read_lock
977
def get_revision_graph(self, revision_id=None):
978
"""Return a dictionary containing the revision graph.
979
980
:param revision_id: The revision_id to get a graph from. If None, then
981
the entire revision graph is returned. This is a deprecated mode of
982
operation and will be removed in the future.
983
:return: a dictionary of revision_id->revision_parents_list.
984
"""
985
# special case NULL_REVISION
986
if revision_id == _mod_revision.NULL_REVISION:
987
return {}
988
a_weave = self._get_revision_vf()
989
entire_graph = a_weave.get_graph()
990
if revision_id is None:
991
return a_weave.get_graph()
992
elif revision_id not in a_weave:
993
raise errors.NoSuchRevision(self, revision_id)
994
else:
995
# add what can be reached from revision_id
996
result = {}
997
pending = set([revision_id])
998
while len(pending) > 0:
999
node = pending.pop()
1000
result[node] = a_weave.get_parents(node)
1001
for revision_id in result[node]:
1002
if revision_id not in result:
1003
pending.add(revision_id)
1004
return result
1005
1006
@needs_read_lock
1007
def get_revision_graph_with_ghosts(self, revision_ids=None):
1008
"""Return a graph of the revisions with ghosts marked as applicable.
1009
1010
:param revision_ids: an iterable of revisions to graph or None for all.
1011
:return: a Graph object with the graph reachable from revision_ids.
1012
"""
1013
result = graph.Graph()
1014
vf = self._get_revision_vf()
1015
versions = set(vf.versions())
1016
if not revision_ids:
1017
pending = set(self.all_revision_ids())
1018
required = set([])
1019
else:
1020
pending = set(revision_ids)
1021
# special case NULL_REVISION
1022
if _mod_revision.NULL_REVISION in pending:
1023
pending.remove(_mod_revision.NULL_REVISION)
1024
required = set(pending)
1025
done = set([])
1026
while len(pending):
1027
revision_id = pending.pop()
1028
if not revision_id in versions:
1029
if revision_id in required:
1030
raise errors.NoSuchRevision(self, revision_id)
1031
# a ghost
1032
result.add_ghost(revision_id)
1033
# mark it as done so we don't try for it again.
1034
done.add(revision_id)
1035
continue
1036
parent_ids = vf.get_parents_with_ghosts(revision_id)
1037
for parent_id in parent_ids:
1038
# is this queued or done ?
1039
if (parent_id not in pending and
1040
parent_id not in done):
1041
# no, queue it.
1042
pending.add(parent_id)
1043
result.add_node(revision_id, parent_ids)
1044
done.add(revision_id)
1045
return result
1046
1047
def _get_revision_vf(self):
1048
""":return: a versioned file containing the revisions."""
1049
vf = self._revision_store.get_revision_file(self.get_transaction())
1050
return vf
1051
1052
@needs_write_lock
1053
def reconcile(self, other=None, thorough=False):
1054
"""Reconcile this repository."""
1055
from bzrlib.reconcile import KnitReconciler
1056
reconciler = KnitReconciler(self, thorough=thorough)
1057
reconciler.reconcile()
1058
return reconciler
1057
class RepositoryFormatRegistry(registry.Registry):
1058
"""Registry of RepositoryFormats.
1059
"""
1060
1061
def get(self, format_string):
1062
r = registry.Registry.get(self, format_string)
1063
if callable(r):
1064
r = r()
1065
return r
1059
1066
1060
def revision_parents(self, revision_id):
1061
return self._get_revision_vf().get_parents(revision_id)
1062
1063
1064
class KnitRepository2(KnitRepository):
1065
""""""
1066
def __init__(self, _format, a_bzrdir, control_files, _revision_store,
1067
control_store, text_store):
1068
KnitRepository.__init__(self, _format, a_bzrdir, control_files,
1069
_revision_store, control_store, text_store)
1070
self._serializer = xml6.serializer_v6
1071
1072
def deserialise_inventory(self, revision_id, xml):
1073
"""Transform the xml into an inventory object.
1074
1075
:param revision_id: The expected revision id of the inventory.
1076
:param xml: A serialised inventory.
1077
"""
1078
result = self._serializer.read_inventory_from_string(xml)
1079
assert result.root.revision is not None
1080
return result
1081
1082
def serialise_inventory(self, inv):
1083
"""Transform the inventory object into XML text.
1084
1085
:param revision_id: The expected revision id of the inventory.
1086
:param xml: A serialised inventory.
1087
"""
1088
assert inv.revision_id is not None
1089
assert inv.root.revision is not None
1090
return KnitRepository.serialise_inventory(self, inv)
1091
1092
def get_commit_builder(self, branch, parents, config, timestamp=None,
1093
timezone=None, committer=None, revprops=None,
1094
revision_id=None):
1095
"""Obtain a CommitBuilder for this repository.
1096
1097
:param branch: Branch to commit to.
1098
:param parents: Revision ids of the parents of the new revision.
1099
:param config: Configuration to use.
1100
:param timestamp: Optional timestamp recorded for commit.
1101
:param timezone: Optional timezone for timestamp.
1102
:param committer: Optional committer to set for commit.
1103
:param revprops: Optional dictionary of revision properties.
1104
:param revision_id: Optional revision id.
1105
"""
1106
return RootCommitBuilder(self, parents, config, timestamp, timezone,
1107
committer, revprops, revision_id)
1108
1067
1068
format_registry = RepositoryFormatRegistry()
1069
"""Registry of formats, indexed by their identifying format string.
1070
1071
This can contain either format instances themselves, or classes/factories that
1072
can be called to obtain one.
1073
"""
1074
1075
1076
#####################################################################
1077
# Repository Formats
1109
1078
1110
1079
class RepositoryFormat(object):
1111
1080
"""A repository format.
1131
1100
parameterisation.
1132
1101
"""
1133
1102
1134
_default_format = None
1135
"""The default format used for new repositories."""
1136
1137
_formats = {}
1138
"""The known formats."""
1139
1140
1103
def __str__(self):
1141
1104
return "<%s>" % self.__class__.__name__
1142
1105
1106
def __eq__(self, other):
1107
# format objects are generally stateless
1108
return isinstance(other, self.__class__)
1109
1110
def __ne__(self, other):
1111
return not self == other
1112
1143
1113
@classmethod
1144
1114
def find_format(klass, a_bzrdir):
1145
"""Return the format for the repository object in a_bzrdir."""
1115
"""Return the format for the repository object in a_bzrdir.
1116
1117
This is used by bzr native formats that have a "format" file in
1118
the repository. Other methods may be used by different types of
1119
control directory.
1120
"""
1146
1121
try:
1147
1122
transport = a_bzrdir.get_repository_transport(None)
1148
1123
format_string = transport.get("format").read()
1149
return klass._formats[format_string]
1124
return format_registry.get(format_string)
1150
1125
except errors.NoSuchFile:
1151
1126
raise errors.NoRepositoryPresent(a_bzrdir)
1152
1127
except KeyError:
1153
1128
raise errors.UnknownFormatError(format=format_string)
1154
1129
1155
def _get_control_store(self, repo_transport, control_files):
1156
"""Return the control store for this repository."""
1157
raise NotImplementedError(self._get_control_store)
1130
@classmethod
1131
def register_format(klass, format):
1132
format_registry.register(format.get_format_string(), format)
1133
1134
@classmethod
1135
def unregister_format(klass, format):
1136
format_registry.remove(format.get_format_string())
1158
1137
1159
1138
@classmethod
1160
1139
def get_default_format(klass):
1161
1140
"""Return the current default format."""
1162
return klass._default_format
1141
from bzrlib import bzrdir
1142
return bzrdir.format_registry.make_bzrdir('default').repository_format
1143
1144
def _get_control_store(self, repo_transport, control_files):
1145
"""Return the control store for this repository."""
1146
raise NotImplementedError(self._get_control_store)
1163
1147
1164
1148
def get_format_string(self):
1165
1149
"""Return the ASCII format string that identifies this format.
1192
1176
from bzrlib.store.revision.text import TextRevisionStore
1193
1177
dir_mode = control_files._dir_mode
1194
1178
file_mode = control_files._file_mode
1195
text_store =TextStore(transport.clone(name),
1179
text_store = TextStore(transport.clone(name),
1196
1180
prefixed=prefixed,
1197
1181
compressed=compressed,
1198
1182
dir_mode=dir_mode,
1200
1184
_revision_store = TextRevisionStore(text_store, serializer)
1201
1185
return _revision_store
1202
1186
1187
# TODO: this shouldn't be in the base class, it's specific to things that
1188
# use weaves or knits -- mbp 20070207
1203
1189
def _get_versioned_file_store(self,
1204
1190
name,
1205
1191
transport,
1206
1192
control_files,
1207
1193
prefixed=True,
1208
versionedfile_class=weave.WeaveFile,
1194
versionedfile_class=None,
1209
1195
versionedfile_kwargs={},
1210
1196
escaped=False):
1197
if versionedfile_class is None:
1198
versionedfile_class = self._versionedfile_class
1211
1199
weave_transport = control_files._transport.clone(name)
1212
1200
dir_mode = control_files._dir_mode
1213
1201
file_mode = control_files._file_mode
1223
1211
1224
1212
:param a_bzrdir: The bzrdir to put the new repository in it.
1225
1213
:param shared: The repository should be initialized as a sharable one.
1226
1214
:returns: The new repository object.
1215
1227
1216
This may raise UninitializableFormat if shared repository are not
1228
1217
compatible the a_bzrdir.
1229
1218
"""
1219
raise NotImplementedError(self.initialize)
1230
1220
1231
1221
def is_supported(self):
1232
1222
"""Is this format supported?
1247
1237
"""
1248
1238
raise NotImplementedError(self.open)
1249
1239
1250
@classmethod
1251
def register_format(klass, format):
1252
klass._formats[format.get_format_string()] = format
1253
1254
@classmethod
1255
def set_default_format(klass, format):
1256
klass._default_format = format
1257
1258
@classmethod
1259
def unregister_format(klass, format):
1260
assert klass._formats[format.get_format_string()] is format
1261
del klass._formats[format.get_format_string()]
1262
1263
1264
class PreSplitOutRepositoryFormat(RepositoryFormat):
1265
"""Base class for the pre split out repository formats."""
1266
1267
rich_root_data = False
1268
1269
def initialize(self, a_bzrdir, shared=False, _internal=False):
1270
"""Create a weave repository.
1271
1272
TODO: when creating split out bzr branch formats, move this to a common
1273
base for Format5, Format6. or something like that.
1274
"""
1275
if shared:
1276
raise errors.IncompatibleFormat(self, a_bzrdir._format)
1277
1278
if not _internal:
1279
# always initialized when the bzrdir is.
1280
return self.open(a_bzrdir, _found=True)
1281
1282
# Create an empty weave
1283
sio = StringIO()
1284
weavefile.write_weave_v5(weave.Weave(), sio)
1285
empty_weave = sio.getvalue()
1286
1287
mutter('creating repository in %s.', a_bzrdir.transport.base)
1288
dirs = ['revision-store', 'weaves']
1289
files = [('inventory.weave', StringIO(empty_weave)),
1290
]
1291
1292
# FIXME: RBC 20060125 don't peek under the covers
1293
# NB: no need to escape relative paths that are url safe.
1294
control_files = lockable_files.LockableFiles(a_bzrdir.transport,
1295
'branch-lock', lockable_files.TransportLock)
1296
control_files.create_lock()
1297
control_files.lock_write()
1298
control_files._transport.mkdir_multi(dirs,
1299
mode=control_files._dir_mode)
1300
try:
1301
for file, content in files:
1302
control_files.put(file, content)
1303
finally:
1304
control_files.unlock()
1305
return self.open(a_bzrdir, _found=True)
1306
1307
def _get_control_store(self, repo_transport, control_files):
1308
"""Return the control store for this repository."""
1309
return self._get_versioned_file_store('',
1310
repo_transport,
1311
control_files,
1312
prefixed=False)
1313
1314
def _get_text_store(self, transport, control_files):
1315
"""Get a store for file texts for this format."""
1316
raise NotImplementedError(self._get_text_store)
1317
1318
def open(self, a_bzrdir, _found=False):
1319
"""See RepositoryFormat.open()."""
1320
if not _found:
1321
# we are being called directly and must probe.
1322
raise NotImplementedError
1323
1324
repo_transport = a_bzrdir.get_repository_transport(None)
1325
control_files = a_bzrdir._control_files
1326
text_store = self._get_text_store(repo_transport, control_files)
1327
control_store = self._get_control_store(repo_transport, control_files)
1328
_revision_store = self._get_revision_store(repo_transport, control_files)
1329
return AllInOneRepository(_format=self,
1330
a_bzrdir=a_bzrdir,
1331
_revision_store=_revision_store,
1332
control_store=control_store,
1333
text_store=text_store)
1334
1335
def check_conversion_target(self, target_format):
1336
pass
1337
1338
1339
class RepositoryFormat4(PreSplitOutRepositoryFormat):
1340
"""Bzr repository format 4.
1341
1342
This repository format has:
1343
- flat stores
1344
- TextStores for texts, inventories,revisions.
1345
1346
This format is deprecated: it indexes texts using a text id which is
1347
removed in format 5; initialization and write support for this format
1348
has been removed.
1349
"""
1350
1351
def __init__(self):
1352
super(RepositoryFormat4, self).__init__()
1353
self._matchingbzrdir = bzrdir.BzrDirFormat4()
1354
1355
def get_format_description(self):
1356
"""See RepositoryFormat.get_format_description()."""
1357
return "Repository format 4"
1358
1359
def initialize(self, url, shared=False, _internal=False):
1360
"""Format 4 branches cannot be created."""
1361
raise errors.UninitializableFormat(self)
1362
1363
def is_supported(self):
1364
"""Format 4 is not supported.
1365
1366
It is not supported because the model changed from 4 to 5 and the
1367
conversion logic is expensive - so doing it on the fly was not
1368
feasible.
1369
"""
1370
return False
1371
1372
def _get_control_store(self, repo_transport, control_files):
1373
"""Format 4 repositories have no formal control store at this point.
1374
1375
This will cause any control-file-needing apis to fail - this is desired.
1376
"""
1377
return None
1378
1379
def _get_revision_store(self, repo_transport, control_files):
1380
"""See RepositoryFormat._get_revision_store()."""
1381
from bzrlib.xml4 import serializer_v4
1382
return self._get_text_rev_store(repo_transport,
1383
control_files,
1384
'revision-store',
1385
serializer=serializer_v4)
1386
1387
def _get_text_store(self, transport, control_files):
1388
"""See RepositoryFormat._get_text_store()."""
1389
1390
1391
class RepositoryFormat5(PreSplitOutRepositoryFormat):
1392
"""Bzr control format 5.
1393
1394
This repository format has:
1395
- weaves for file texts and inventory
1396
- flat stores
1397
- TextStores for revisions and signatures.
1398
"""
1399
1400
def __init__(self):
1401
super(RepositoryFormat5, self).__init__()
1402
self._matchingbzrdir = bzrdir.BzrDirFormat5()
1403
1404
def get_format_description(self):
1405
"""See RepositoryFormat.get_format_description()."""
1406
return "Weave repository format 5"
1407
1408
def _get_revision_store(self, repo_transport, control_files):
1409
"""See RepositoryFormat._get_revision_store()."""
1410
"""Return the revision store object for this a_bzrdir."""
1411
return self._get_text_rev_store(repo_transport,
1412
control_files,
1413
'revision-store',
1414
compressed=False)
1415
1416
def _get_text_store(self, transport, control_files):
1417
"""See RepositoryFormat._get_text_store()."""
1418
return self._get_versioned_file_store('weaves', transport, control_files, prefixed=False)
1419
1420
1421
class RepositoryFormat6(PreSplitOutRepositoryFormat):
1422
"""Bzr control format 6.
1423
1424
This repository format has:
1425
- weaves for file texts and inventory
1426
- hash subdirectory based stores.
1427
- TextStores for revisions and signatures.
1428
"""
1429
1430
def __init__(self):
1431
super(RepositoryFormat6, self).__init__()
1432
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1433
1434
def get_format_description(self):
1435
"""See RepositoryFormat.get_format_description()."""
1436
return "Weave repository format 6"
1437
1438
def _get_revision_store(self, repo_transport, control_files):
1439
"""See RepositoryFormat._get_revision_store()."""
1440
return self._get_text_rev_store(repo_transport,
1441
control_files,
1442
'revision-store',
1443
compressed=False,
1444
prefixed=True)
1445
1446
def _get_text_store(self, transport, control_files):
1447
"""See RepositoryFormat._get_text_store()."""
1448
return self._get_versioned_file_store('weaves', transport, control_files)
1449
1450
1240
1451
1241
class MetaDirRepositoryFormat(RepositoryFormat):
1452
1242
"""Common base class for the new repositories using the metadir layout."""
1453
1243
1454
1244
rich_root_data = False
1245
supports_tree_reference = False
1246
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1455
1247
1456
1248
def __init__(self):
1457
1249
super(MetaDirRepositoryFormat, self).__init__()
1458
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1459
1250
1460
1251
def _create_control_files(self, a_bzrdir):
1461
1252
"""Create the required files and the initial control_files object."""
1484
1275
control_files.unlock()
1485
1276
1486
1277
1487
class RepositoryFormat7(MetaDirRepositoryFormat):
1488
"""Bzr repository 7.
1489
1490
This repository format has:
1491
- weaves for file texts and inventory
1492
- hash subdirectory based stores.
1493
- TextStores for revisions and signatures.
1494
- a format marker of its own
1495
- an optional 'shared-storage' flag
1496
- an optional 'no-working-trees' flag
1497
"""
1498
1499
def _get_control_store(self, repo_transport, control_files):
1500
"""Return the control store for this repository."""
1501
return self._get_versioned_file_store('',
1502
repo_transport,
1503
control_files,
1504
prefixed=False)
1505
1506
def get_format_string(self):
1507
"""See RepositoryFormat.get_format_string()."""
1508
return "Bazaar-NG Repository format 7"
1509
1510
def get_format_description(self):
1511
"""See RepositoryFormat.get_format_description()."""
1512
return "Weave repository format 7"
1513
1514
def check_conversion_target(self, target_format):
1515
pass
1516
1517
def _get_revision_store(self, repo_transport, control_files):
1518
"""See RepositoryFormat._get_revision_store()."""
1519
return self._get_text_rev_store(repo_transport,
1520
control_files,
1521
'revision-store',
1522
compressed=False,
1523
prefixed=True,
1524
)
1525
1526
def _get_text_store(self, transport, control_files):
1527
"""See RepositoryFormat._get_text_store()."""
1528
return self._get_versioned_file_store('weaves',
1529
transport,
1530
control_files)
1531
1532
def initialize(self, a_bzrdir, shared=False):
1533
"""Create a weave repository.
1534
1535
:param shared: If true the repository will be initialized as a shared
1536
repository.
1537
"""
1538
# Create an empty weave
1539
sio = StringIO()
1540
weavefile.write_weave_v5(weave.Weave(), sio)
1541
empty_weave = sio.getvalue()
1542
1543
mutter('creating repository in %s.', a_bzrdir.transport.base)
1544
dirs = ['revision-store', 'weaves']
1545
files = [('inventory.weave', StringIO(empty_weave)),
1546
]
1547
utf8_files = [('format', self.get_format_string())]
1548
1549
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1550
return self.open(a_bzrdir=a_bzrdir, _found=True)
1551
1552
def open(self, a_bzrdir, _found=False, _override_transport=None):
1553
"""See RepositoryFormat.open().
1554
1555
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1556
repository at a slightly different url
1557
than normal. I.e. during 'upgrade'.
1558
"""
1559
if not _found:
1560
format = RepositoryFormat.find_format(a_bzrdir)
1561
assert format.__class__ == self.__class__
1562
if _override_transport is not None:
1563
repo_transport = _override_transport
1564
else:
1565
repo_transport = a_bzrdir.get_repository_transport(None)
1566
control_files = lockable_files.LockableFiles(repo_transport,
1567
'lock', lockdir.LockDir)
1568
text_store = self._get_text_store(repo_transport, control_files)
1569
control_store = self._get_control_store(repo_transport, control_files)
1570
_revision_store = self._get_revision_store(repo_transport, control_files)
1571
return WeaveMetaDirRepository(_format=self,
1572
a_bzrdir=a_bzrdir,
1573
control_files=control_files,
1574
_revision_store=_revision_store,
1575
control_store=control_store,
1576
text_store=text_store)
1577
1578
1579
class RepositoryFormatKnit(MetaDirRepositoryFormat):
1580
"""Bzr repository knit format (generalized).
1581
1582
This repository format has:
1583
- knits for file texts and inventory
1584
- hash subdirectory based stores.
1585
- knits for revisions and signatures
1586
- TextStores for revisions and signatures.
1587
- a format marker of its own
1588
- an optional 'shared-storage' flag
1589
- an optional 'no-working-trees' flag
1590
- a LockDir lock
1591
"""
1592
1593
def _get_control_store(self, repo_transport, control_files):
1594
"""Return the control store for this repository."""
1595
return VersionedFileStore(
1596
repo_transport,
1597
prefixed=False,
1598
file_mode=control_files._file_mode,
1599
versionedfile_class=knit.KnitVersionedFile,
1600
versionedfile_kwargs={'factory':knit.KnitPlainFactory()},
1601
)
1602
1603
def _get_revision_store(self, repo_transport, control_files):
1604
"""See RepositoryFormat._get_revision_store()."""
1605
from bzrlib.store.revision.knit import KnitRevisionStore
1606
versioned_file_store = VersionedFileStore(
1607
repo_transport,
1608
file_mode=control_files._file_mode,
1609
prefixed=False,
1610
precious=True,
1611
versionedfile_class=knit.KnitVersionedFile,
1612
versionedfile_kwargs={'delta':False,
1613
'factory':knit.KnitPlainFactory(),
1614
},
1615
escaped=True,
1616
)
1617
return KnitRevisionStore(versioned_file_store)
1618
1619
def _get_text_store(self, transport, control_files):
1620
"""See RepositoryFormat._get_text_store()."""
1621
return self._get_versioned_file_store('knits',
1622
transport,
1623
control_files,
1624
versionedfile_class=knit.KnitVersionedFile,
1625
versionedfile_kwargs={
1626
'create_parent_dir':True,
1627
'delay_create':True,
1628
'dir_mode':control_files._dir_mode,
1629
},
1630
escaped=True)
1631
1632
def initialize(self, a_bzrdir, shared=False):
1633
"""Create a knit format 1 repository.
1634
1635
:param a_bzrdir: bzrdir to contain the new repository; must already
1636
be initialized.
1637
:param shared: If true the repository will be initialized as a shared
1638
repository.
1639
"""
1640
mutter('creating repository in %s.', a_bzrdir.transport.base)
1641
dirs = ['revision-store', 'knits']
1642
files = []
1643
utf8_files = [('format', self.get_format_string())]
1644
1645
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
1646
repo_transport = a_bzrdir.get_repository_transport(None)
1647
control_files = lockable_files.LockableFiles(repo_transport,
1648
'lock', lockdir.LockDir)
1649
control_store = self._get_control_store(repo_transport, control_files)
1650
transaction = transactions.WriteTransaction()
1651
# trigger a write of the inventory store.
1652
control_store.get_weave_or_empty('inventory', transaction)
1653
_revision_store = self._get_revision_store(repo_transport, control_files)
1654
# the revision id here is irrelevant: it will not be stored, and cannot
1655
# already exist.
1656
_revision_store.has_revision_id('A', transaction)
1657
_revision_store.get_signature_file(transaction)
1658
return self.open(a_bzrdir=a_bzrdir, _found=True)
1659
1660
def open(self, a_bzrdir, _found=False, _override_transport=None):
1661
"""See RepositoryFormat.open().
1662
1663
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1664
repository at a slightly different url
1665
than normal. I.e. during 'upgrade'.
1666
"""
1667
if not _found:
1668
format = RepositoryFormat.find_format(a_bzrdir)
1669
assert format.__class__ == self.__class__
1670
if _override_transport is not None:
1671
repo_transport = _override_transport
1672
else:
1673
repo_transport = a_bzrdir.get_repository_transport(None)
1674
control_files = lockable_files.LockableFiles(repo_transport,
1675
'lock', lockdir.LockDir)
1676
text_store = self._get_text_store(repo_transport, control_files)
1677
control_store = self._get_control_store(repo_transport, control_files)
1678
_revision_store = self._get_revision_store(repo_transport, control_files)
1679
return KnitRepository(_format=self,
1680
a_bzrdir=a_bzrdir,
1681
control_files=control_files,
1682
_revision_store=_revision_store,
1683
control_store=control_store,
1684
text_store=text_store)
1685
1686
1687
class RepositoryFormatKnit1(RepositoryFormatKnit):
1688
"""Bzr repository knit format 1.
1689
1690
This repository format has:
1691
- knits for file texts and inventory
1692
- hash subdirectory based stores.
1693
- knits for revisions and signatures
1694
- TextStores for revisions and signatures.
1695
- a format marker of its own
1696
- an optional 'shared-storage' flag
1697
- an optional 'no-working-trees' flag
1698
- a LockDir lock
1699
1700
This format was introduced in bzr 0.8.
1701
"""
1702
def get_format_string(self):
1703
"""See RepositoryFormat.get_format_string()."""
1704
return "Bazaar-NG Knit Repository Format 1"
1705
1706
def get_format_description(self):
1707
"""See RepositoryFormat.get_format_description()."""
1708
return "Knit repository format 1"
1709
1710
def check_conversion_target(self, target_format):
1711
pass
1712
1713
1714
class RepositoryFormatKnit2(RepositoryFormatKnit):
1715
"""Bzr repository knit format 2.
1716
1717
THIS FORMAT IS EXPERIMENTAL
1718
This repository format has:
1719
- knits for file texts and inventory
1720
- hash subdirectory based stores.
1721
- knits for revisions and signatures
1722
- TextStores for revisions and signatures.
1723
- a format marker of its own
1724
- an optional 'shared-storage' flag
1725
- an optional 'no-working-trees' flag
1726
- a LockDir lock
1727
- Support for recording full info about the tree root
1728
1729
"""
1730
1731
rich_root_data = True
1732
1733
def get_format_string(self):
1734
"""See RepositoryFormat.get_format_string()."""
1735
return "Bazaar Knit Repository Format 2\n"
1736
1737
def get_format_description(self):
1738
"""See RepositoryFormat.get_format_description()."""
1739
return "Knit repository format 2"
1740
1741
def check_conversion_target(self, target_format):
1742
if not target_format.rich_root_data:
1743
raise errors.BadConversionTarget(
1744
'Does not support rich root data.', target_format)
1745
1746
def open(self, a_bzrdir, _found=False, _override_transport=None):
1747
"""See RepositoryFormat.open().
1748
1749
:param _override_transport: INTERNAL USE ONLY. Allows opening the
1750
repository at a slightly different url
1751
than normal. I.e. during 'upgrade'.
1752
"""
1753
if not _found:
1754
format = RepositoryFormat.find_format(a_bzrdir)
1755
assert format.__class__ == self.__class__
1756
if _override_transport is not None:
1757
repo_transport = _override_transport
1758
else:
1759
repo_transport = a_bzrdir.get_repository_transport(None)
1760
control_files = lockable_files.LockableFiles(repo_transport, 'lock',
1761
lockdir.LockDir)
1762
text_store = self._get_text_store(repo_transport, control_files)
1763
control_store = self._get_control_store(repo_transport, control_files)
1764
_revision_store = self._get_revision_store(repo_transport, control_files)
1765
return KnitRepository2(_format=self,
1766
a_bzrdir=a_bzrdir,
1767
control_files=control_files,
1768
_revision_store=_revision_store,
1769
control_store=control_store,
1770
text_store=text_store)
1771
1772
1773
1774
1278
# formats which have no format string are not discoverable
1775
# and not independently creatable, so are not registered.
1776
RepositoryFormat.register_format(RepositoryFormat7())
1777
_default_format = RepositoryFormatKnit1()
1778
RepositoryFormat.register_format(_default_format)
1779
RepositoryFormat.register_format(RepositoryFormatKnit2())
1780
RepositoryFormat.set_default_format(_default_format)
1781
_legacy_formats = [RepositoryFormat4(),
1782
RepositoryFormat5(),
1783
RepositoryFormat6()]
1279
# and not independently creatable, so are not registered. They're
1280
# all in bzrlib.repofmt.weaverepo now. When an instance of one of these is
1281
# needed, it's constructed directly by the BzrDir. Non-native formats where
1282
# the repository is not separately opened are similar.
1283
1284
format_registry.register_lazy(
1285
'Bazaar-NG Repository format 7',
1286
'bzrlib.repofmt.weaverepo',
1287
'RepositoryFormat7'
1288
)
1289
# KEEP in sync with bzrdir.format_registry default, which controls the overall
1290
# default control directory format
1291
1292
format_registry.register_lazy(
1293
'Bazaar-NG Knit Repository Format 1',
1294
'bzrlib.repofmt.knitrepo',
1295
'RepositoryFormatKnit1',
1296
)
1297
format_registry.default_key = 'Bazaar-NG Knit Repository Format 1'
1298
1299
format_registry.register_lazy(
1300
'Bazaar Knit Repository Format 3 (bzr 0.15)\n',
1301
'bzrlib.repofmt.knitrepo',
1302
'RepositoryFormatKnit3',
1303
)
1784
1304
1785
1305
1786
1306
class InterRepository(InterObject):
1798
1318
_optimisers = []
1799
1319
"""The available optimised InterRepository types."""
1800
1320
1801
def copy_content(self, revision_id=None, basis=None):
1321
def copy_content(self, revision_id=None):
1802
1322
raise NotImplementedError(self.copy_content)
1803
1323
1804
1324
def fetch(self, revision_id=None, pb=None):
1828
1348
# generic, possibly worst case, slow code path.
1829
1349
target_ids = set(self.target.all_revision_ids())
1830
1350
if revision_id is not None:
1351
# TODO: jam 20070210 InterRepository is internal enough that it
1352
# should assume revision_ids are already utf-8
1353
revision_id = osutils.safe_revision_id(revision_id)
1831
1354
source_ids = self.source.get_ancestry(revision_id)
1832
1355
assert source_ids[0] is None
1833
1356
source_ids.pop(0)
1846
1369
Data format and model must match for this to work.
1847
1370
"""
1848
1371
1849
_matching_repo_format = RepositoryFormat4()
1850
"""Repository format for testing with."""
1372
@classmethod
1373
def _get_repo_format_to_test(self):
1374
"""Repository format for testing with."""
1375
return RepositoryFormat.get_default_format()
1851
1376
1852
1377
@staticmethod
1853
1378
def is_compatible(source, target):
1854
if not isinstance(source, Repository):
1855
return False
1856
if not isinstance(target, Repository):
1857
return False
1858
if source._format.rich_root_data == target._format.rich_root_data:
1859
return True
1860
else:
1861
return False
1379
if source.supports_rich_root() != target.supports_rich_root():
1380
return False
1381
if source._serializer != target._serializer:
1382
return False
1383
return True
1862
1384
1863
1385
@needs_write_lock
1864
def copy_content(self, revision_id=None, basis=None):
1386
def copy_content(self, revision_id=None):
1865
1387
"""Make a complete copy of the content in self into destination.
1866
1388
1867
1389
This is a destructive operation! Do not use it on existing
1869
1391
1870
1392
:param revision_id: Only copy the content needed to construct
1871
1393
revision_id and its parents.
1872
:param basis: Copy the needed data preferentially from basis.
1873
1394
"""
1874
1395
try:
1875
1396
self.target.set_make_working_trees(self.source.make_working_trees())
1876
1397
except NotImplementedError:
1877
1398
pass
1878
# grab the basis available data
1879
if basis is not None:
1880
self.target.fetch(basis, revision_id=revision_id)
1399
# TODO: jam 20070210 This is fairly internal, so we should probably
1400
# just assert that revision_id is not unicode.
1401
revision_id = osutils.safe_revision_id(revision_id)
1881
1402
# but don't bother fetching if we have the needed data now.
1882
1403
if (revision_id not in (None, _mod_revision.NULL_REVISION) and
1883
1404
self.target.has_revision(revision_id)):
1891
1412
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1892
1413
self.source, self.source._format, self.target,
1893
1414
self.target._format)
1415
# TODO: jam 20070210 This should be an assert, not a translate
1416
revision_id = osutils.safe_revision_id(revision_id)
1894
1417
f = GenericRepoFetcher(to_repository=self.target,
1895
1418
from_repository=self.source,
1896
1419
last_revision=revision_id,
1901
1424
class InterWeaveRepo(InterSameDataRepository):
1902
1425
"""Optimised code paths between Weave based repositories."""
1903
1426
1904
_matching_repo_format = RepositoryFormat7()
1905
"""Repository format for testing with."""
1427
@classmethod
1428
def _get_repo_format_to_test(self):
1429
from bzrlib.repofmt import weaverepo
1430
return weaverepo.RepositoryFormat7()
1906
1431
1907
1432
@staticmethod
1908
1433
def is_compatible(source, target):
1912
1437
could lead to confusing results, and there is no need to be
1913
1438
overly general.
1914
1439
"""
1440
from bzrlib.repofmt.weaverepo import (
1441
RepositoryFormat5,
1442
RepositoryFormat6,
1443
RepositoryFormat7,
1444
)
1915
1445
try:
1916
1446
return (isinstance(source._format, (RepositoryFormat5,
1917
1447
RepositoryFormat6,
1923
1453
return False
1924
1454
1925
1455
@needs_write_lock
1926
def copy_content(self, revision_id=None, basis=None):
1456
def copy_content(self, revision_id=None):
1927
1457
"""See InterRepository.copy_content()."""
1928
1458
# weave specific optimised path:
1929
if basis is not None:
1930
# copy the basis in, then fetch remaining data.
1931
basis.copy_content_into(self.target, revision_id)
1932
# the basis copy_content_into could miss-set this.
1459
# TODO: jam 20070210 Internal, should be an assert, not translate
1460
revision_id = osutils.safe_revision_id(revision_id)
1461
try:
1462
self.target.set_make_working_trees(self.source.make_working_trees())
1463
except NotImplementedError:
1464
pass
1465
# FIXME do not peek!
1466
if self.source.control_files._transport.listable():
1467
pb = ui.ui_factory.nested_progress_bar()
1933
1468
try:
1934
self.target.set_make_working_trees(self.source.make_working_trees())
1935
except NotImplementedError:
1936
pass
1469
self.target.weave_store.copy_all_ids(
1470
self.source.weave_store,
1471
pb=pb,
1472
from_transaction=self.source.get_transaction(),
1473
to_transaction=self.target.get_transaction())
1474
pb.update('copying inventory', 0, 1)
1475
self.target.control_weaves.copy_multi(
1476
self.source.control_weaves, ['inventory'],
1477
from_transaction=self.source.get_transaction(),
1478
to_transaction=self.target.get_transaction())
1479
self.target._revision_store.text_store.copy_all_ids(
1480
self.source._revision_store.text_store,
1481
pb=pb)
1482
finally:
1483
pb.finished()
1484
else:
1937
1485
self.target.fetch(self.source, revision_id=revision_id)
1938
else:
1939
try:
1940
self.target.set_make_working_trees(self.source.make_working_trees())
1941
except NotImplementedError:
1942
pass
1943
# FIXME do not peek!
1944
if self.source.control_files._transport.listable():
1945
pb = ui.ui_factory.nested_progress_bar()
1946
try:
1947
self.target.weave_store.copy_all_ids(
1948
self.source.weave_store,
1949
pb=pb,
1950
from_transaction=self.source.get_transaction(),
1951
to_transaction=self.target.get_transaction())
1952
pb.update('copying inventory', 0, 1)
1953
self.target.control_weaves.copy_multi(
1954
self.source.control_weaves, ['inventory'],
1955
from_transaction=self.source.get_transaction(),
1956
to_transaction=self.target.get_transaction())
1957
self.target._revision_store.text_store.copy_all_ids(
1958
self.source._revision_store.text_store,
1959
pb=pb)
1960
finally:
1961
pb.finished()
1962
else:
1963
self.target.fetch(self.source, revision_id=revision_id)
1964
1486
1965
1487
@needs_write_lock
1966
1488
def fetch(self, revision_id=None, pb=None):
1968
1490
from bzrlib.fetch import GenericRepoFetcher
1969
1491
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
1970
1492
self.source, self.source._format, self.target, self.target._format)
1493
# TODO: jam 20070210 This should be an assert, not a translate
1494
revision_id = osutils.safe_revision_id(revision_id)
1971
1495
f = GenericRepoFetcher(to_repository=self.target,
1972
1496
from_repository=self.source,
1973
1497
last_revision=revision_id,
2019
1543
class InterKnitRepo(InterSameDataRepository):
2020
1544
"""Optimised code paths between Knit based repositories."""
2021
1545
2022
_matching_repo_format = RepositoryFormatKnit1()
2023
"""Repository format for testing with."""
1546
@classmethod
1547
def _get_repo_format_to_test(self):
1548
from bzrlib.repofmt import knitrepo
1549
return knitrepo.RepositoryFormatKnit1()
2024
1550
2025
1551
@staticmethod
2026
1552
def is_compatible(source, target):
2030
1556
could lead to confusing results, and there is no need to be
2031
1557
overly general.
2032
1558
"""
1559
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1
2033
1560
try:
2034
1561
return (isinstance(source._format, (RepositoryFormatKnit1)) and
2035
1562
isinstance(target._format, (RepositoryFormatKnit1)))
2042
1569
from bzrlib.fetch import KnitRepoFetcher
2043
1570
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2044
1571
self.source, self.source._format, self.target, self.target._format)
1572
# TODO: jam 20070210 This should be an assert, not a translate
1573
revision_id = osutils.safe_revision_id(revision_id)
2045
1574
f = KnitRepoFetcher(to_repository=self.target,
2046
1575
from_repository=self.source,
2047
1576
last_revision=revision_id,
2081
1610
2082
1611
class InterModel1and2(InterRepository):
2083
1612
2084
_matching_repo_format = None
1613
@classmethod
1614
def _get_repo_format_to_test(self):
1615
return None
2085
1616
2086
1617
@staticmethod
2087
1618
def is_compatible(source, target):
2088
if not isinstance(source, Repository):
2089
return False
2090
if not isinstance(target, Repository):
2091
return False
2092
if not source._format.rich_root_data and target._format.rich_root_data:
1619
if not source.supports_rich_root() and target.supports_rich_root():
2093
1620
return True
2094
1621
else:
2095
1622
return False
2098
1625
def fetch(self, revision_id=None, pb=None):
2099
1626
"""See InterRepository.fetch()."""
2100
1627
from bzrlib.fetch import Model1toKnit2Fetcher
1628
# TODO: jam 20070210 This should be an assert, not a translate
1629
revision_id = osutils.safe_revision_id(revision_id)
2101
1630
f = Model1toKnit2Fetcher(to_repository=self.target,
2102
1631
from_repository=self.source,
2103
1632
last_revision=revision_id,
2105
1634
return f.count_copied, f.failed_revisions
2106
1635
2107
1636
@needs_write_lock
2108
def copy_content(self, revision_id=None, basis=None):
1637
def copy_content(self, revision_id=None):
2109
1638
"""Make a complete copy of the content in self into destination.
2110
1639
2111
1640
This is a destructive operation! Do not use it on existing
2113
1642
2114
1643
:param revision_id: Only copy the content needed to construct
2115
1644
revision_id and its parents.
2116
:param basis: Copy the needed data preferentially from basis.
2117
1645
"""
2118
1646
try:
2119
1647
self.target.set_make_working_trees(self.source.make_working_trees())
2120
1648
except NotImplementedError:
2121
1649
pass
2122
# grab the basis available data
2123
if basis is not None:
2124
self.target.fetch(basis, revision_id=revision_id)
1650
# TODO: jam 20070210 Internal, assert, don't translate
1651
revision_id = osutils.safe_revision_id(revision_id)
2125
1652
# but don't bother fetching if we have the needed data now.
2126
1653
if (revision_id not in (None, _mod_revision.NULL_REVISION) and
2127
1654
self.target.has_revision(revision_id)):
2131
1658
2132
1659
class InterKnit1and2(InterKnitRepo):
2133
1660
2134
_matching_repo_format = None
1661
@classmethod
1662
def _get_repo_format_to_test(self):
1663
return None
2135
1664
2136
1665
@staticmethod
2137
1666
def is_compatible(source, target):
2138
"""Be compatible with Knit1 source and Knit2 target"""
1667
"""Be compatible with Knit1 source and Knit3 target"""
1668
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit3
2139
1669
try:
1670
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1, \
1671
RepositoryFormatKnit3
2140
1672
return (isinstance(source._format, (RepositoryFormatKnit1)) and
2141
isinstance(target._format, (RepositoryFormatKnit2)))
1673
isinstance(target._format, (RepositoryFormatKnit3)))
2142
1674
except AttributeError:
2143
1675
return False
2144
1676
2149
1681
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2150
1682
self.source, self.source._format, self.target,
2151
1683
self.target._format)
1684
# TODO: jam 20070210 This should be an assert, not a translate
1685
revision_id = osutils.safe_revision_id(revision_id)
2152
1686
f = Knit1to2Fetcher(to_repository=self.target,
2153
1687
from_repository=self.source,
2154
1688
last_revision=revision_id,
2156
1690
return f.count_copied, f.failed_revisions
2157
1691
2158
1692
1693
class InterRemoteRepository(InterRepository):
1694
"""Code for converting between RemoteRepository objects.
1695
1696
This just gets an non-remote repository from the RemoteRepository, and calls
1697
InterRepository.get again.
1698
"""
1699
1700
def __init__(self, source, target):
1701
if isinstance(source, remote.RemoteRepository):
1702
source._ensure_real()
1703
real_source = source._real_repository
1704
else:
1705
real_source = source
1706
if isinstance(target, remote.RemoteRepository):
1707
target._ensure_real()
1708
real_target = target._real_repository
1709
else:
1710
real_target = target
1711
self.real_inter = InterRepository.get(real_source, real_target)
1712
1713
@staticmethod
1714
def is_compatible(source, target):
1715
if isinstance(source, remote.RemoteRepository):
1716
return True
1717
if isinstance(target, remote.RemoteRepository):
1718
return True
1719
return False
1720
1721
def copy_content(self, revision_id=None):
1722
self.real_inter.copy_content(revision_id=revision_id)
1723
1724
def fetch(self, revision_id=None, pb=None):
1725
self.real_inter.fetch(revision_id=revision_id, pb=pb)
1726
1727
@classmethod
1728
def _get_repo_format_to_test(self):
1729
return None
1730
1731
2159
1732
InterRepository.register_optimiser(InterSameDataRepository)
2160
1733
InterRepository.register_optimiser(InterWeaveRepo)
2161
1734
InterRepository.register_optimiser(InterKnitRepo)
2162
1735
InterRepository.register_optimiser(InterModel1and2)
2163
1736
InterRepository.register_optimiser(InterKnit1and2)
1737
InterRepository.register_optimiser(InterRemoteRepository)
2164
1738
2165
1739
2166
1740
class RepositoryTestProviderAdapter(object):
2172
1746
to make it easy to identify.
2173
1747
"""
2174
1748
2175
def __init__(self, transport_server, transport_readonly_server, formats):
1749
def __init__(self, transport_server, transport_readonly_server, formats,
1750
vfs_transport_factory=None):
2176
1751
self._transport_server = transport_server
2177
1752
self._transport_readonly_server = transport_readonly_server
1753
self._vfs_transport_factory = vfs_transport_factory
2178
1754
self._formats = formats
2179
1755
2180
1756
def adapt(self, test):
2181
1757
result = unittest.TestSuite()
2182
1758
for repository_format, bzrdir_format in self._formats:
1759
from copy import deepcopy
2183
1760
new_test = deepcopy(test)
2184
1761
new_test.transport_server = self._transport_server
2185
1762
new_test.transport_readonly_server = self._transport_readonly_server
1763
# Only override the test's vfs_transport_factory if one was
1764
# specified, otherwise just leave the default in place.
1765
if self._vfs_transport_factory:
1766
new_test.vfs_transport_factory = self._vfs_transport_factory
2186
1767
new_test.bzrdir_format = bzrdir_format
2187
1768
new_test.repository_format = repository_format
2188
1769
def make_new_test_id():
2210
1791
def adapt(self, test):
2211
1792
result = unittest.TestSuite()
2212
1793
for interrepo_class, repository_format, repository_format_to in self._formats:
1794
from copy import deepcopy
2213
1795
new_test = deepcopy(test)
2214
1796
new_test.transport_server = self._transport_server
2215
1797
new_test.transport_readonly_server = self._transport_readonly_server
2226
1808
@staticmethod
2227
1809
def default_test_list():
2228
1810
"""Generate the default list of interrepo permutations to test."""
1811
from bzrlib.repofmt import knitrepo, weaverepo
2229
1812
result = []
2230
1813
# test the default InterRepository between format 6 and the current
2231
1814
# default format.
2234
1817
#result.append((InterRepository,
2235
1818
# RepositoryFormat6(),
2236
1819
# RepositoryFormatKnit1()))
2237
for optimiser in InterRepository._optimisers:
2238
if optimiser._matching_repo_format is not None:
2239
result.append((optimiser,
2240
optimiser._matching_repo_format,
2241
optimiser._matching_repo_format
2242
))
1820
for optimiser_class in InterRepository._optimisers:
1821
format_to_test = optimiser_class._get_repo_format_to_test()
1822
if format_to_test is not None:
1823
result.append((optimiser_class,
1824
format_to_test, format_to_test))
2243
1825
# if there are specific combinations we want to use, we can add them
2244
1826
# here.
2245
result.append((InterModel1and2, RepositoryFormat5(),
2246
RepositoryFormatKnit2()))
2247
result.append((InterKnit1and2, RepositoryFormatKnit1(),
2248
RepositoryFormatKnit2()))
1827
result.append((InterModel1and2,
1828
weaverepo.RepositoryFormat5(),
1829
knitrepo.RepositoryFormatKnit3()))
1830
result.append((InterKnit1and2,
1831
knitrepo.RepositoryFormatKnit1(),
1832
knitrepo.RepositoryFormatKnit3()))
2249
1833
return result
2250
1834
2251
1835
2332
1916
self._committer = committer
2333
1917
2334
1918
self.new_inventory = Inventory(None)
2335
self._new_revision_id = revision_id
1919
self._new_revision_id = osutils.safe_revision_id(revision_id)
2336
1920
self.parents = parents
2337
1921
self.repository = repository
2338
1922
2346
1930
self._timestamp = round(timestamp, 3)
2347
1931
2348
1932
if timezone is None:
2349
self._timezone = local_time_offset()
1933
self._timezone = osutils.local_time_offset()
2350
1934
else:
2351
1935
self._timezone = int(timezone)
2352
1936
2460
2044
:param file_parents: The per-file parent revision ids.
2461
2045
"""
2462
2046
self._add_text_to_weave(file_id, [], file_parents.keys())
2047
2048
def modified_reference(self, file_id, file_parents):
2049
"""Record the modification of a reference.
2050
2051
:param file_id: The file_id of the link to record.
2052
:param file_parents: The per-file parent revision ids.
2053
"""
2054
self._add_text_to_weave(file_id, [], file_parents.keys())
2463
2055
2464
2056
def modified_file_text(self, file_id, file_parents,
2465
2057
get_content_byte_lines, text_sha1=None,
2564
2156
2565
2157
2566
2158
def _unescaper(match, _map=_unescape_map):
2567
return _map[match.group(1)]
2159
code = match.group(1)
2160
try:
2161
return _map[code]
2162
except KeyError:
2163
if not code.startswith('#'):
2164
raise
2165
return unichr(int(code[1:])).encode('utf8')
2568
2166
2569
2167
2570
2168
_unescape_re = None
2576
2174
if _unescape_re is None:
2577
2175
_unescape_re = re.compile('\&([^;]*);')
2578
2176
return _unescape_re.sub(_unescaper, data)
2579
2580
2581
def _unescape_xml_cached(data, cache):
2582
try:
2583
return cache[data]
2584
except KeyError:
2585
unescaped = _unescape_xml(data)
2586
cache[data] = unescaped
2587
return unescaped
Loggerhead is a web-based interface for Breezy
Version: 2.0.1