« back to all changes in this revision
Viewing changes to bzrlib/repository.py
- browse files at revision 2474.1.23
- compare with another revision
- download diff
- download tarball
- view history from revision 2474.1.23
- Committer: John Arbash Meinel
- Date: 2007-05-04 18:59:36 UTC
- mto: This revision was merged to the branch mainline in revision 2643.
- Revision ID: john@arbash-meinel.com-20070504185936-1mjdoqmtz74xe5mg
A C implementation of _fields_to_entry_0_parents drops the time from 400ms to 330ms for a 21k-entry tree
- files added:
- bzrlib/bundle/common.py
- bzrlib/bundle/old
- bzrlib/compiled
- bzrlib/tests/compiled
- files removed:
- bzrlib/_dirstate_helpers_c.h
- bzrlib/help_topics
- bzrlib/help_topics/en
- bzrlib/tests/commands
- bzrlib/tests/inventory_implementations
- bzrlib/util/tests
- doc/developers
- doc/en
- doc/en/admin-guide
- doc/en/developer-guide
- doc/en/mini-tutorial
- doc/en/quick-reference
- doc/en/release-notes
- doc/en/tutorials
- doc/en/user-guide
- doc/en/user-guide/images
- doc/en/user-reference
- files renamed:
- doc/developers/HACKING.txt => HACKING
- bzrlib/_dirstate_helpers_c.pyx => bzrlib/compiled/dirstate_helpers.pyx
- bzrlib/deprecated_graph.py => bzrlib/graph.py
- bzrlib/help_topics/__init__.py => bzrlib/help_topics.py
- bzrlib/_patiencediff_py.py => bzrlib/patiencediff.py
- bzrlib/plugins/launchpad/lp_directory.py => bzrlib/plugins/launchpad/lp_indirect.py
- bzrlib/plugins/launchpad/test_lp_directory.py => bzrlib/plugins/launchpad/test_lp_indirect.py
- bzrlib/tests/http_utils.py => bzrlib/tests/HTTPTestUtil.py
- bzrlib/tests/http_server.py => bzrlib/tests/HttpServer.py
- bzrlib/tests/blackbox/test_send.py => bzrlib/tests/blackbox/test_bundle.py
- bzrlib/tests/test__dirstate_helpers.py => bzrlib/tests/compiled/test_dirstate_helpers.py
- bzrlib/tests/test_deprecated_graph.py => bzrlib/tests/test_graph.py
- bzrlib/tests/test_revisionspec.py => bzrlib/tests/test_revisionnamespaces.py
- doc/en/tutorials/centralized_workflow.txt => doc/centralized_workflow.txt
- bzrlib/help_topics/en/configuration.txt => doc/configuration.txt
- doc/en/user-guide/http_smart_server.txt => doc/http_smart_server.txt
- doc/en/user-guide/index.txt => doc/index.txt
- doc/en/user-guide/plugins.txt => doc/plugins.txt
- doc/en/user-guide/server.txt => doc/server.txt
- doc/en/user-guide/setting_up_email.txt => doc/setting_up_email.txt
- doc/en/user-guide/specifying_revisions.txt => doc/specifying_revisions.txt
- doc/en/tutorials/tutorial.txt => doc/tutorial.txt
- doc/en/user-guide/using_aliases.txt => doc/using_aliases.txt
- doc/en/user-guide/version_info.txt => doc/version_info.txt
- files modified:
- .bzrignore
added
removed
bzrlib/repository.py
20
20
lazy_import(globals(), """
21
21
import re
22
22
import time
23
import unittest
23
24
24
25
from bzrlib import (
25
26
bzrdir,
26
27
check,
27
debug,
28
deprecated_graph,
29
28
errors,
30
29
generate_ids,
31
30
gpg,
33
32
lazy_regex,
34
33
lockable_files,
35
34
lockdir,
36
lru_cache,
37
35
osutils,
38
36
registry,
39
37
remote,
40
38
revision as _mod_revision,
41
39
symbol_versioning,
42
40
transactions,
43
tsort,
44
41
ui,
45
42
)
46
from bzrlib.bundle import serializer
47
43
from bzrlib.revisiontree import RevisionTree
48
44
from bzrlib.store.versioned import VersionedFileStore
49
45
from bzrlib.store.text import TextStore
50
46
from bzrlib.testament import Testament
51
from bzrlib.util import bencode
47
52
48
""")
53
49
54
50
from bzrlib.decorators import needs_read_lock, needs_write_lock
56
52
from bzrlib.inventory import Inventory, InventoryDirectory, ROOT_ID
57
53
from bzrlib.symbol_versioning import (
58
54
deprecated_method,
55
zero_nine,
59
56
)
60
from bzrlib.trace import mutter, mutter_callsite, note, warning
57
from bzrlib.trace import mutter, note, warning
61
58
62
59
63
60
# Old formats display a warning, but only once
64
61
_deprecation_warning_done = False
65
62
66
63
67
class CommitBuilder(object):
68
"""Provides an interface to build up a commit.
69
70
This allows describing a tree to be committed without needing to
71
know the internals of the format of the repository.
72
"""
73
74
# all clients should supply tree roots.
75
record_root_entry = True
76
# the default CommitBuilder does not manage trees whose root is versioned.
77
_versioned_root = False
78
79
def __init__(self, repository, parents, config, timestamp=None,
80
timezone=None, committer=None, revprops=None,
81
revision_id=None):
82
"""Initiate a CommitBuilder.
83
84
:param repository: Repository to commit to.
85
:param parents: Revision ids of the parents of the new revision.
86
:param config: Configuration to use.
87
:param timestamp: Optional timestamp recorded for commit.
88
:param timezone: Optional timezone for timestamp.
89
:param committer: Optional committer to set for commit.
90
:param revprops: Optional dictionary of revision properties.
91
:param revision_id: Optional revision id.
92
"""
93
self._config = config
94
95
if committer is None:
96
self._committer = self._config.username()
97
else:
98
assert isinstance(committer, basestring), type(committer)
99
self._committer = committer
100
101
self.new_inventory = Inventory(None)
102
self._new_revision_id = revision_id
103
self.parents = parents
104
self.repository = repository
105
106
self._revprops = {}
107
if revprops is not None:
108
self._revprops.update(revprops)
109
110
if timestamp is None:
111
timestamp = time.time()
112
# Restrict resolution to 1ms
113
self._timestamp = round(timestamp, 3)
114
115
if timezone is None:
116
self._timezone = osutils.local_time_offset()
117
else:
118
self._timezone = int(timezone)
119
120
self._generate_revision_if_needed()
121
self.__heads = graph.HeadsCache(repository.get_graph()).heads
122
123
def commit(self, message):
124
"""Make the actual commit.
125
126
:return: The revision id of the recorded revision.
127
"""
128
rev = _mod_revision.Revision(
129
timestamp=self._timestamp,
130
timezone=self._timezone,
131
committer=self._committer,
132
message=message,
133
inventory_sha1=self.inv_sha1,
134
revision_id=self._new_revision_id,
135
properties=self._revprops)
136
rev.parent_ids = self.parents
137
self.repository.add_revision(self._new_revision_id, rev,
138
self.new_inventory, self._config)
139
self.repository.commit_write_group()
140
return self._new_revision_id
141
142
def abort(self):
143
"""Abort the commit that is being built.
144
"""
145
self.repository.abort_write_group()
146
147
def revision_tree(self):
148
"""Return the tree that was just committed.
149
150
After calling commit() this can be called to get a RevisionTree
151
representing the newly committed tree. This is preferred to
152
calling Repository.revision_tree() because that may require
153
deserializing the inventory, while we already have a copy in
154
memory.
155
"""
156
return RevisionTree(self.repository, self.new_inventory,
157
self._new_revision_id)
158
159
def finish_inventory(self):
160
"""Tell the builder that the inventory is finished."""
161
if self.new_inventory.root is None:
162
raise AssertionError('Root entry should be supplied to'
163
' record_entry_contents, as of bzr 0.10.',
164
DeprecationWarning, stacklevel=2)
165
self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
166
self.new_inventory.revision_id = self._new_revision_id
167
self.inv_sha1 = self.repository.add_inventory(
168
self._new_revision_id,
169
self.new_inventory,
170
self.parents
171
)
172
173
def _gen_revision_id(self):
174
"""Return new revision-id."""
175
return generate_ids.gen_revision_id(self._config.username(),
176
self._timestamp)
177
178
def _generate_revision_if_needed(self):
179
"""Create a revision id if None was supplied.
180
181
If the repository can not support user-specified revision ids
182
they should override this function and raise CannotSetRevisionId
183
if _new_revision_id is not None.
184
185
:raises: CannotSetRevisionId
186
"""
187
if self._new_revision_id is None:
188
self._new_revision_id = self._gen_revision_id()
189
self.random_revid = True
190
else:
191
self.random_revid = False
192
193
def _heads(self, file_id, revision_ids):
194
"""Calculate the graph heads for revision_ids in the graph of file_id.
195
196
This can use either a per-file graph or a global revision graph as we
197
have an identity relationship between the two graphs.
198
"""
199
return self.__heads(revision_ids)
200
201
def _check_root(self, ie, parent_invs, tree):
202
"""Helper for record_entry_contents.
203
204
:param ie: An entry being added.
205
:param parent_invs: The inventories of the parent revisions of the
206
commit.
207
:param tree: The tree that is being committed.
208
"""
209
# In this revision format, root entries have no knit or weave When
210
# serializing out to disk and back in root.revision is always
211
# _new_revision_id
212
ie.revision = self._new_revision_id
213
214
def _get_delta(self, ie, basis_inv, path):
215
"""Get a delta against the basis inventory for ie."""
216
if ie.file_id not in basis_inv:
217
# add
218
return (None, path, ie.file_id, ie)
219
elif ie != basis_inv[ie.file_id]:
220
# common but altered
221
# TODO: avoid tis id2path call.
222
return (basis_inv.id2path(ie.file_id), path, ie.file_id, ie)
223
else:
224
# common, unaltered
225
return None
226
227
def record_entry_contents(self, ie, parent_invs, path, tree,
228
content_summary):
229
"""Record the content of ie from tree into the commit if needed.
230
231
Side effect: sets ie.revision when unchanged
232
233
:param ie: An inventory entry present in the commit.
234
:param parent_invs: The inventories of the parent revisions of the
235
commit.
236
:param path: The path the entry is at in the tree.
237
:param tree: The tree which contains this entry and should be used to
238
obtain content.
239
:param content_summary: Summary data from the tree about the paths
240
content - stat, length, exec, sha/link target. This is only
241
accessed when the entry has a revision of None - that is when it is
242
a candidate to commit.
243
:return: A tuple (change_delta, version_recorded). change_delta is
244
an inventory_delta change for this entry against the basis tree of
245
the commit, or None if no change occured against the basis tree.
246
version_recorded is True if a new version of the entry has been
247
recorded. For instance, committing a merge where a file was only
248
changed on the other side will return (delta, False).
249
"""
250
if self.new_inventory.root is None:
251
if ie.parent_id is not None:
252
raise errors.RootMissing()
253
self._check_root(ie, parent_invs, tree)
254
if ie.revision is None:
255
kind = content_summary[0]
256
else:
257
# ie is carried over from a prior commit
258
kind = ie.kind
259
# XXX: repository specific check for nested tree support goes here - if
260
# the repo doesn't want nested trees we skip it ?
261
if (kind == 'tree-reference' and
262
not self.repository._format.supports_tree_reference):
263
# mismatch between commit builder logic and repository:
264
# this needs the entry creation pushed down into the builder.
265
raise NotImplementedError('Missing repository subtree support.')
266
self.new_inventory.add(ie)
267
268
# TODO: slow, take it out of the inner loop.
269
try:
270
basis_inv = parent_invs[0]
271
except IndexError:
272
basis_inv = Inventory(root_id=None)
273
274
# ie.revision is always None if the InventoryEntry is considered
275
# for committing. We may record the previous parents revision if the
276
# content is actually unchanged against a sole head.
277
if ie.revision is not None:
278
if not self._versioned_root and path == '':
279
# repositories that do not version the root set the root's
280
# revision to the new commit even when no change occurs, and
281
# this masks when a change may have occurred against the basis,
282
# so calculate if one happened.
283
if ie.file_id in basis_inv:
284
delta = (basis_inv.id2path(ie.file_id), path,
285
ie.file_id, ie)
286
else:
287
# add
288
delta = (None, path, ie.file_id, ie)
289
return delta, False
290
else:
291
# we don't need to commit this, because the caller already
292
# determined that an existing revision of this file is
293
# appropriate.
294
return None, (ie.revision == self._new_revision_id)
295
# XXX: Friction: parent_candidates should return a list not a dict
296
# so that we don't have to walk the inventories again.
297
parent_candiate_entries = ie.parent_candidates(parent_invs)
298
head_set = self._heads(ie.file_id, parent_candiate_entries.keys())
299
heads = []
300
for inv in parent_invs:
301
if ie.file_id in inv:
302
old_rev = inv[ie.file_id].revision
303
if old_rev in head_set:
304
heads.append(inv[ie.file_id].revision)
305
head_set.remove(inv[ie.file_id].revision)
306
307
store = False
308
# now we check to see if we need to write a new record to the
309
# file-graph.
310
# We write a new entry unless there is one head to the ancestors, and
311
# the kind-derived content is unchanged.
312
313
# Cheapest check first: no ancestors, or more the one head in the
314
# ancestors, we write a new node.
315
if len(heads) != 1:
316
store = True
317
if not store:
318
# There is a single head, look it up for comparison
319
parent_entry = parent_candiate_entries[heads[0]]
320
# if the non-content specific data has changed, we'll be writing a
321
# node:
322
if (parent_entry.parent_id != ie.parent_id or
323
parent_entry.name != ie.name):
324
store = True
325
# now we need to do content specific checks:
326
if not store:
327
# if the kind changed the content obviously has
328
if kind != parent_entry.kind:
329
store = True
330
if kind == 'file':
331
assert content_summary[2] is not None, \
332
"Files must not have executable = None"
333
if not store:
334
if (# if the file length changed we have to store:
335
parent_entry.text_size != content_summary[1] or
336
# if the exec bit has changed we have to store:
337
parent_entry.executable != content_summary[2]):
338
store = True
339
elif parent_entry.text_sha1 == content_summary[3]:
340
# all meta and content is unchanged (using a hash cache
341
# hit to check the sha)
342
ie.revision = parent_entry.revision
343
ie.text_size = parent_entry.text_size
344
ie.text_sha1 = parent_entry.text_sha1
345
ie.executable = parent_entry.executable
346
return self._get_delta(ie, basis_inv, path), False
347
else:
348
# Either there is only a hash change(no hash cache entry,
349
# or same size content change), or there is no change on
350
# this file at all.
351
# Provide the parent's hash to the store layer, so that the
352
# content is unchanged we will not store a new node.
353
nostore_sha = parent_entry.text_sha1
354
if store:
355
# We want to record a new node regardless of the presence or
356
# absence of a content change in the file.
357
nostore_sha = None
358
ie.executable = content_summary[2]
359
lines = tree.get_file(ie.file_id, path).readlines()
360
try:
361
ie.text_sha1, ie.text_size = self._add_text_to_weave(
362
ie.file_id, lines, heads, nostore_sha)
363
except errors.ExistingContent:
364
# Turns out that the file content was unchanged, and we were
365
# only going to store a new node if it was changed. Carry over
366
# the entry.
367
ie.revision = parent_entry.revision
368
ie.text_size = parent_entry.text_size
369
ie.text_sha1 = parent_entry.text_sha1
370
ie.executable = parent_entry.executable
371
return self._get_delta(ie, basis_inv, path), False
372
elif kind == 'directory':
373
if not store:
374
# all data is meta here, nothing specific to directory, so
375
# carry over:
376
ie.revision = parent_entry.revision
377
return self._get_delta(ie, basis_inv, path), False
378
lines = []
379
self._add_text_to_weave(ie.file_id, lines, heads, None)
380
elif kind == 'symlink':
381
current_link_target = content_summary[3]
382
if not store:
383
# symlink target is not generic metadata, check if it has
384
# changed.
385
if current_link_target != parent_entry.symlink_target:
386
store = True
387
if not store:
388
# unchanged, carry over.
389
ie.revision = parent_entry.revision
390
ie.symlink_target = parent_entry.symlink_target
391
return self._get_delta(ie, basis_inv, path), False
392
ie.symlink_target = current_link_target
393
lines = []
394
self._add_text_to_weave(ie.file_id, lines, heads, None)
395
elif kind == 'tree-reference':
396
if not store:
397
if content_summary[3] != parent_entry.reference_revision:
398
store = True
399
if not store:
400
# unchanged, carry over.
401
ie.reference_revision = parent_entry.reference_revision
402
ie.revision = parent_entry.revision
403
return self._get_delta(ie, basis_inv, path), False
404
ie.reference_revision = content_summary[3]
405
lines = []
406
self._add_text_to_weave(ie.file_id, lines, heads, None)
407
else:
408
raise NotImplementedError('unknown kind')
409
ie.revision = self._new_revision_id
410
return self._get_delta(ie, basis_inv, path), True
411
412
def _add_text_to_weave(self, file_id, new_lines, parents, nostore_sha):
413
versionedfile = self.repository.weave_store.get_weave_or_empty(
414
file_id, self.repository.get_transaction())
415
# Don't change this to add_lines - add_lines_with_ghosts is cheaper
416
# than add_lines, and allows committing when a parent is ghosted for
417
# some reason.
418
# Note: as we read the content directly from the tree, we know its not
419
# been turned into unicode or badly split - but a broken tree
420
# implementation could give us bad output from readlines() so this is
421
# not a guarantee of safety. What would be better is always checking
422
# the content during test suite execution. RBC 20070912
423
try:
424
return versionedfile.add_lines_with_ghosts(
425
self._new_revision_id, parents, new_lines,
426
nostore_sha=nostore_sha, random_id=self.random_revid,
427
check_content=False)[0:2]
428
finally:
429
versionedfile.clear_cache()
430
431
432
class RootCommitBuilder(CommitBuilder):
433
"""This commitbuilder actually records the root id"""
434
435
# the root entry gets versioned properly by this builder.
436
_versioned_root = True
437
438
def _check_root(self, ie, parent_invs, tree):
439
"""Helper for record_entry_contents.
440
441
:param ie: An entry being added.
442
:param parent_invs: The inventories of the parent revisions of the
443
commit.
444
:param tree: The tree that is being committed.
445
"""
446
447
448
64
######################################################################
449
65
# Repositories
450
66
460
76
remote) disk.
461
77
"""
462
78
463
# What class to use for a CommitBuilder. Often its simpler to change this
464
# in a Repository class subclass rather than to override
465
# get_commit_builder.
466
_commit_builder_class = CommitBuilder
467
# The search regex used by xml based repositories to determine what things
468
# where changed in a single commit.
469
79
_file_ids_altered_regex = lazy_regex.lazy_compile(
470
80
r'file_id="(?P<file_id>[^"]+)"'
471
r'.* revision="(?P<revision_id>[^"]+)"'
81
r'.*revision="(?P<revision_id>[^"]+)"'
472
82
)
473
83
474
def abort_write_group(self):
475
"""Commit the contents accrued within the current write group.
476
477
:seealso: start_write_group.
478
"""
479
if self._write_group is not self.get_transaction():
480
# has an unlock or relock occured ?
481
raise errors.BzrError('mismatched lock context and write group.')
482
self._abort_write_group()
483
self._write_group = None
484
485
def _abort_write_group(self):
486
"""Template method for per-repository write group cleanup.
487
488
This is called during abort before the write group is considered to be
489
finished and should cleanup any internal state accrued during the write
490
group. There is no requirement that data handed to the repository be
491
*not* made available - this is not a rollback - but neither should any
492
attempt be made to ensure that data added is fully commited. Abort is
493
invoked when an error has occured so futher disk or network operations
494
may not be possible or may error and if possible should not be
495
attempted.
496
"""
497
84
@needs_write_lock
498
85
def add_inventory(self, revision_id, inv, parents):
499
86
"""Add the inventory inv to the repository as revision_id.
500
87
501
88
:param parents: The revision ids of the parents that revision_id
502
89
is known to have and are in the repository already.
503
90
504
:returns: The validator(which is a sha1 digest, though what is sha'd is
505
repository format specific) of the serialized inventory.
91
returns the sha1 of the serialized inventory.
506
92
"""
507
assert self.is_in_write_group()
93
revision_id = osutils.safe_revision_id(revision_id)
508
94
_mod_revision.check_not_reserved_id(revision_id)
509
95
assert inv.revision_id is None or inv.revision_id == revision_id, \
510
96
"Mismatch between inventory revision" \
511
97
" id and insertion revid (%r, %r)" % (inv.revision_id, revision_id)
512
98
assert inv.root is not None
513
inv_lines = self._serialise_inventory_to_lines(inv)
514
inv_vf = self.get_inventory_weave()
515
return self._inventory_add_lines(inv_vf, revision_id, parents,
516
inv_lines, check_content=False)
99
inv_text = self.serialise_inventory(inv)
100
inv_sha1 = osutils.sha_string(inv_text)
101
inv_vf = self.control_weaves.get_weave('inventory',
102
self.get_transaction())
103
self._inventory_add_lines(inv_vf, revision_id, parents,
104
osutils.split_lines(inv_text))
105
return inv_sha1
517
106
518
def _inventory_add_lines(self, inv_vf, revision_id, parents, lines,
519
check_content=True):
520
"""Store lines in inv_vf and return the sha1 of the inventory."""
107
def _inventory_add_lines(self, inv_vf, revision_id, parents, lines):
521
108
final_parents = []
522
109
for parent in parents:
523
110
if parent in inv_vf:
524
111
final_parents.append(parent)
525
return inv_vf.add_lines(revision_id, final_parents, lines,
526
check_content=check_content)[0]
527
112
113
inv_vf.add_lines(revision_id, final_parents, lines)
114
115
@needs_write_lock
528
116
def add_revision(self, revision_id, rev, inv=None, config=None):
529
117
"""Add rev to the revision store as revision_id.
530
118
536
124
If supplied its signature_needed method will be used
537
125
to determine if a signature should be made.
538
126
"""
127
revision_id = osutils.safe_revision_id(revision_id)
539
128
# TODO: jam 20070210 Shouldn't we check rev.revision_id and
540
129
# rev.parent_ids?
541
130
_mod_revision.check_not_reserved_id(revision_id)
551
140
self.get_inventory_weave())
552
141
else:
553
142
# yes, this is not suitable for adding with ghosts.
554
rev.inventory_sha1 = self.add_inventory(revision_id, inv,
555
rev.parent_ids)
143
self.add_inventory(revision_id, inv, rev.parent_ids)
556
144
self._revision_store.add_revision(rev, self.get_transaction())
557
145
558
def _add_revision_text(self, revision_id, text):
559
revision = self._revision_store._serializer.read_revision_from_string(
560
text)
561
self._revision_store._add_revision(revision, StringIO(text),
562
self.get_transaction())
146
@needs_read_lock
147
def _all_possible_ids(self):
148
"""Return all the possible revisions that we could find."""
149
return self.get_inventory_weave().versions()
563
150
564
151
def all_revision_ids(self):
565
152
"""Returns a list of all the revision ids in the repository.
568
155
reachable from a particular revision, and ignore any other revisions
569
156
that might be present. There is no direct replacement method.
570
157
"""
571
if 'evil' in debug.debug_flags:
572
mutter_callsite(2, "all_revision_ids is linear with history.")
573
158
return self._all_revision_ids()
574
159
160
@needs_read_lock
575
161
def _all_revision_ids(self):
576
162
"""Returns a list of all the revision ids in the repository.
577
163
578
164
These are in as much topological order as the underlying store can
579
present.
165
present: for weaves ghosts may lead to a lack of correctness until
166
the reweave updates the parents list.
580
167
"""
581
raise NotImplementedError(self._all_revision_ids)
168
if self._revision_store.text_store.listable():
169
return self._revision_store.all_revision_ids(self.get_transaction())
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)
174
return self._eliminate_revisions_not_present(result)
582
175
583
176
def break_lock(self):
584
177
"""Break a lock if one is present from another instance.
621
214
self.bzrdir = a_bzrdir
622
215
self.control_files = control_files
623
216
self._revision_store = _revision_store
217
self.text_store = text_store
624
218
# backwards compatibility
625
219
self.weave_store = text_store
626
# for tests
627
self._reconcile_does_inventory_gc = True
628
self._reconcile_fixes_text_parents = False
629
self._reconcile_backsup_inventory = True
630
220
# not right yet - should be more semantically clear ?
631
221
#
632
222
self.control_store = control_store
634
224
# TODO: make sure to construct the right store classes, etc, depending
635
225
# on whether escaping is required.
636
226
self._warn_if_deprecated()
637
self._write_group = None
638
self.base = control_files._transport.base
639
227
640
228
def __repr__(self):
641
return '%s(%r)' % (self.__class__.__name__,
642
self.base)
643
644
def has_same_location(self, other):
645
"""Returns a boolean indicating if this repository is at the same
646
location as another repository.
647
648
This might return False even when two repository objects are accessing
649
the same physical repository via different URLs.
650
"""
651
if self.__class__ is not other.__class__:
652
return False
653
return (self.control_files._transport.base ==
654
other.control_files._transport.base)
655
656
def is_in_write_group(self):
657
"""Return True if there is an open write group.
658
659
:seealso: start_write_group.
660
"""
661
return self._write_group is not None
229
return '%s(%r)' % (self.__class__.__name__,
230
self.bzrdir.transport.base)
662
231
663
232
def is_locked(self):
664
233
return self.control_files.is_locked()
665
234
666
def is_write_locked(self):
667
"""Return True if this object is write locked."""
668
return self.is_locked() and self.control_files._lock_mode == 'w'
669
670
235
def lock_write(self, token=None):
671
236
"""Lock this repository for writing.
672
673
This causes caching within the repository obejct to start accumlating
674
data during reads, and allows a 'write_group' to be obtained. Write
675
groups must be used for actual data insertion.
676
237
677
238
:param token: if this is already locked, then lock_write will fail
678
239
unless the token matches the existing lock.
681
242
instance doesn't support using token locks.
682
243
:raises MismatchedToken: if the specified token doesn't match the token
683
244
of the existing lock.
684
:seealso: start_write_group.
685
245
686
246
A token should be passed in if you know that you have locked the object
687
247
some other way, and need to synchronise this object's state with that
689
249
690
250
XXX: this docstring is duplicated in many places, e.g. lockable_files.py
691
251
"""
692
result = self.control_files.lock_write(token=token)
693
self._refresh_data()
694
return result
252
return self.control_files.lock_write(token=token)
695
253
696
254
def lock_read(self):
697
255
self.control_files.lock_read()
698
self._refresh_data()
699
256
700
257
def get_physical_lock_status(self):
701
258
return self.control_files.get_physical_lock_status()
766
323
result['size'] = t
767
324
return result
768
325
769
def find_branches(self, using=False):
770
"""Find branches underneath this repository.
771
772
This will include branches inside other branches.
773
774
:param using: If True, list only branches using this repository.
775
"""
776
if using and not self.is_shared():
777
try:
778
return [self.bzrdir.open_branch()]
779
except errors.NotBranchError:
780
return []
781
class Evaluator(object):
782
783
def __init__(self):
784
self.first_call = True
785
786
def __call__(self, bzrdir):
787
# On the first call, the parameter is always the bzrdir
788
# containing the current repo.
789
if not self.first_call:
790
try:
791
repository = bzrdir.open_repository()
792
except errors.NoRepositoryPresent:
793
pass
794
else:
795
return False, (None, repository)
796
self.first_call = False
797
try:
798
value = (bzrdir.open_branch(), None)
799
except errors.NotBranchError:
800
value = (None, None)
801
return True, value
802
803
branches = []
804
for branch, repository in bzrdir.BzrDir.find_bzrdirs(
805
self.bzrdir.root_transport, evaluate=Evaluator()):
806
if branch is not None:
807
branches.append(branch)
808
if not using and repository is not None:
809
branches.extend(repository.find_branches())
810
return branches
811
812
def get_data_stream(self, revision_ids):
813
raise NotImplementedError(self.get_data_stream)
814
815
def get_data_stream_for_search(self, search_result):
816
"""Get a data stream that can be inserted to a repository.
817
818
:param search_result: A bzrlib.graph.SearchResult selecting the
819
revisions to get.
820
:return: A data stream that can be inserted into a repository using
821
insert_data_stream.
822
"""
823
raise NotImplementedError(self.get_data_stream_for_search)
824
825
def insert_data_stream(self, stream):
826
"""XXX What does this really do?
827
828
Is it a substitute for fetch?
829
Should it manage its own write group ?
830
"""
831
for item_key, bytes in stream:
832
if item_key[0] == 'file':
833
(file_id,) = item_key[1:]
834
knit = self.weave_store.get_weave_or_empty(
835
file_id, self.get_transaction())
836
elif item_key == ('inventory',):
837
knit = self.get_inventory_weave()
838
elif item_key == ('revisions',):
839
knit = self._revision_store.get_revision_file(
840
self.get_transaction())
841
elif item_key == ('signatures',):
842
knit = self._revision_store.get_signature_file(
843
self.get_transaction())
844
else:
845
raise errors.RepositoryDataStreamError(
846
"Unrecognised data stream key '%s'" % (item_key,))
847
decoded_list = bencode.bdecode(bytes)
848
format = decoded_list.pop(0)
849
data_list = []
850
knit_bytes = ''
851
for version, options, parents, some_bytes in decoded_list:
852
data_list.append((version, options, len(some_bytes), parents))
853
knit_bytes += some_bytes
854
buffer = StringIO(knit_bytes)
855
def reader_func(count):
856
if count is None:
857
return buffer.read()
858
else:
859
return buffer.read(count)
860
knit.insert_data_stream(
861
(format, data_list, reader_func))
862
863
@needs_read_lock
864
def search_missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
865
"""Return the revision ids that other has that this does not.
866
867
These are returned in topological order.
868
869
revision_id: only return revision ids included by revision_id.
870
"""
871
return InterRepository.get(other, self).search_missing_revision_ids(
872
revision_id, find_ghosts)
873
874
@deprecated_method(symbol_versioning.one_two)
875
@needs_read_lock
876
def missing_revision_ids(self, other, revision_id=None, find_ghosts=True):
877
"""Return the revision ids that other has that this does not.
878
879
These are returned in topological order.
880
881
revision_id: only return revision ids included by revision_id.
882
"""
883
keys = self.search_missing_revision_ids(
884
other, revision_id, find_ghosts).get_keys()
885
other.lock_read()
886
try:
887
parents = other.get_graph().get_parent_map(keys)
888
finally:
889
other.unlock()
890
return tsort.topo_sort(parents)
326
@needs_read_lock
327
def missing_revision_ids(self, other, revision_id=None):
328
"""Return the revision ids that other has that this does not.
329
330
These are returned in topological order.
331
332
revision_id: only return revision ids included by revision_id.
333
"""
334
revision_id = osutils.safe_revision_id(revision_id)
335
return InterRepository.get(other, self).missing_revision_ids(revision_id)
891
336
892
337
@staticmethod
893
338
def open(base):
905
350
This is a destructive operation! Do not use it on existing
906
351
repositories.
907
352
"""
353
revision_id = osutils.safe_revision_id(revision_id)
908
354
return InterRepository.get(self, destination).copy_content(revision_id)
909
355
910
def commit_write_group(self):
911
"""Commit the contents accrued within the current write group.
912
913
:seealso: start_write_group.
914
"""
915
if self._write_group is not self.get_transaction():
916
# has an unlock or relock occured ?
917
raise errors.BzrError('mismatched lock context %r and '
918
'write group %r.' %
919
(self.get_transaction(), self._write_group))
920
self._commit_write_group()
921
self._write_group = None
922
923
def _commit_write_group(self):
924
"""Template method for per-repository write group cleanup.
925
926
This is called before the write group is considered to be
927
finished and should ensure that all data handed to the repository
928
for writing during the write group is safely committed (to the
929
extent possible considering file system caching etc).
930
"""
931
932
def fetch(self, source, revision_id=None, pb=None, find_ghosts=False):
356
def fetch(self, source, revision_id=None, pb=None):
933
357
"""Fetch the content required to construct revision_id from source.
934
358
935
359
If revision_id is None all content is copied.
936
:param find_ghosts: Find and copy revisions in the source that are
937
ghosts in the target (and not reachable directly by walking out to
938
the first-present revision in target from revision_id).
939
360
"""
940
# fast path same-url fetch operations
941
if self.has_same_location(source):
942
# check that last_revision is in 'from' and then return a
943
# no-operation.
944
if (revision_id is not None and
945
not _mod_revision.is_null(revision_id)):
946
self.get_revision(revision_id)
947
return 0, []
361
revision_id = osutils.safe_revision_id(revision_id)
948
362
inter = InterRepository.get(source, self)
949
363
try:
950
return inter.fetch(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts)
364
return inter.fetch(revision_id=revision_id, pb=pb)
951
365
except NotImplementedError:
952
366
raise errors.IncompatibleRepositories(source, self)
953
367
954
def create_bundle(self, target, base, fileobj, format=None):
955
return serializer.write_bundle(self, target, base, fileobj, format)
956
957
def get_commit_builder(self, branch, parents, config, timestamp=None,
958
timezone=None, committer=None, revprops=None,
368
def get_commit_builder(self, branch, parents, config, timestamp=None,
369
timezone=None, committer=None, revprops=None,
959
370
revision_id=None):
960
371
"""Obtain a CommitBuilder for this repository.
961
372
968
379
:param revprops: Optional dictionary of revision properties.
969
380
:param revision_id: Optional revision id.
970
381
"""
971
result = self._commit_builder_class(self, parents, config,
972
timestamp, timezone, committer, revprops, revision_id)
973
self.start_write_group()
974
return result
382
revision_id = osutils.safe_revision_id(revision_id)
383
return _CommitBuilder(self, parents, config, timestamp, timezone,
384
committer, revprops, revision_id)
975
385
976
386
def unlock(self):
977
if (self.control_files._lock_count == 1 and
978
self.control_files._lock_mode == 'w'):
979
if self._write_group is not None:
980
self.abort_write_group()
981
self.control_files.unlock()
982
raise errors.BzrError(
983
'Must end write groups before releasing write locks.')
984
387
self.control_files.unlock()
985
388
986
389
@needs_read_lock
998
401
self.copy_content_into(dest_repo, revision_id)
999
402
return dest_repo
1000
403
1001
def start_write_group(self):
1002
"""Start a write group in the repository.
1003
1004
Write groups are used by repositories which do not have a 1:1 mapping
1005
between file ids and backend store to manage the insertion of data from
1006
both fetch and commit operations.
1007
1008
A write lock is required around the start_write_group/commit_write_group
1009
for the support of lock-requiring repository formats.
1010
1011
One can only insert data into a repository inside a write group.
1012
1013
:return: None.
1014
"""
1015
if not self.is_write_locked():
1016
raise errors.NotWriteLocked(self)
1017
if self._write_group:
1018
raise errors.BzrError('already in a write group')
1019
self._start_write_group()
1020
# so we can detect unlock/relock - the write group is now entered.
1021
self._write_group = self.get_transaction()
1022
1023
def _start_write_group(self):
1024
"""Template method for per-repository write group startup.
1025
1026
This is called before the write group is considered to be
1027
entered.
1028
"""
1029
1030
404
@needs_read_lock
1031
405
def sprout(self, to_bzrdir, revision_id=None):
1032
406
"""Create a descendent repository for new development.
1053
427
@needs_read_lock
1054
428
def has_revision(self, revision_id):
1055
429
"""True if this repository has a copy of the revision."""
1056
return revision_id in self.has_revisions((revision_id,))
1057
1058
def has_revisions(self, revision_ids):
1059
"""Probe to find out the presence of multiple revisions.
1060
1061
:param revision_ids: An iterable of revision_ids.
1062
:return: A set of the revision_ids that were present.
1063
"""
1064
raise NotImplementedError(self.has_revisions)
1065
430
revision_id = osutils.safe_revision_id(revision_id)
1066
431
return self._revision_store.has_revision_id(revision_id,
1067
432
self.get_transaction())
1068
433
1069
434
@needs_read_lock
1070
def get_revision(self, revision_id):
1071
"""Return the Revision object for a named revision."""
1072
return self.get_revisions([revision_id])[0]
1073
1074
@needs_read_lock
1075
435
def get_revision_reconcile(self, revision_id):
1076
436
"""'reconcile' helper routine that allows access to a revision always.
1077
437
1080
440
be used by reconcile, or reconcile-alike commands that are correcting
1081
441
or testing the revision graph.
1082
442
"""
1083
return self._get_revisions([revision_id])[0]
443
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]
1084
447
1085
448
@needs_read_lock
1086
449
def get_revisions(self, revision_ids):
1087
"""Get many revisions at once."""
1088
return self._get_revisions(revision_ids)
1089
1090
@needs_read_lock
1091
def _get_revisions(self, revision_ids):
1092
"""Core work logic to get many revisions without sanity checks."""
1093
for rev_id in revision_ids:
1094
if not rev_id or not isinstance(rev_id, basestring):
1095
raise errors.InvalidRevisionId(revision_id=rev_id, branch=self)
450
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1096
451
revs = self._revision_store.get_revisions(revision_ids,
1097
452
self.get_transaction())
1098
453
for rev in revs:
1106
461
# TODO: jam 20070210 This shouldn't be necessary since get_revision
1107
462
# would have already do it.
1108
463
# TODO: jam 20070210 Just use _serializer.write_revision_to_string()
464
revision_id = osutils.safe_revision_id(revision_id)
1109
465
rev = self.get_revision(revision_id)
1110
466
rev_tmp = StringIO()
1111
467
# the current serializer..
1114
470
return rev_tmp.getvalue()
1115
471
1116
472
@needs_read_lock
473
def get_revision(self, revision_id):
474
"""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
r = self.get_revision_reconcile(revision_id)
478
# weave corruption can lead to absent revision markers that should be
479
# present.
480
# the following test is reasonably cheap (it needs a single weave read)
481
# and the weave is cached in read transactions. In write transactions
482
# it is not cached but typically we only read a small number of
483
# revisions. For knits when they are introduced we will probably want
484
# to ensure that caching write transactions are in use.
485
inv = self.get_inventory_weave()
486
self._check_revision_parents(r, inv)
487
return r
488
489
@needs_read_lock
1117
490
def get_deltas_for_revisions(self, revisions):
1118
491
"""Produce a generator of revision deltas.
1119
492
1144
517
r = self.get_revision(revision_id)
1145
518
return list(self.get_deltas_for_revisions([r]))[0]
1146
519
520
def _check_revision_parents(self, revision, inventory):
521
"""Private to Repository and Fetch.
522
523
This checks the parentage of revision in an inventory weave for
524
consistency and is only applicable to inventory-weave-for-ancestry
525
using repository formats & fetchers.
526
"""
527
weave_parents = inventory.get_parents(revision.revision_id)
528
weave_names = inventory.versions()
529
for parent_id in revision.parent_ids:
530
if parent_id in weave_names:
531
# this parent must not be a ghost.
532
if not parent_id in weave_parents:
533
# but it is a ghost
534
raise errors.CorruptRepository(self)
535
1147
536
@needs_write_lock
1148
537
def store_revision_signature(self, gpg_strategy, plaintext, revision_id):
538
revision_id = osutils.safe_revision_id(revision_id)
1149
539
signature = gpg_strategy.sign(plaintext)
1150
self.add_signature_text(revision_id, signature)
1151
1152
@needs_write_lock
1153
def add_signature_text(self, revision_id, signature):
1154
540
self._revision_store.add_revision_signature_text(revision_id,
1155
541
signature,
1156
542
self.get_transaction())
1157
543
1158
def find_text_key_references(self):
1159
"""Find the text key references within the repository.
544
def fileids_altered_by_revision_ids(self, revision_ids):
545
"""Find the file ids and versions affected by revisions.
1160
546
1161
:return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
547
:param revisions: an iterable containing revision ids.
548
:return: a dictionary mapping altered file-ids to an iterable of
1162
549
revision_ids. Each altered file-ids has the exact revision_ids that
1163
550
altered it listed explicitly.
1164
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1165
to whether they were referred to by the inventory of the
1166
revision_id that they contain. The inventory texts from all present
1167
revision ids are assessed to generate this report.
1168
551
"""
1169
revision_ids = self.all_revision_ids()
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)
1170
557
w = self.get_inventory_weave()
1171
pb = ui.ui_factory.nested_progress_bar()
1172
try:
1173
return self._find_text_key_references_from_xml_inventory_lines(
1174
w.iter_lines_added_or_present_in_versions(revision_ids, pb=pb))
1175
finally:
1176
pb.finished()
1177
1178
def _find_text_key_references_from_xml_inventory_lines(self,
1179
line_iterator):
1180
"""Core routine for extracting references to texts from inventories.
1181
1182
This performs the translation of xml lines to revision ids.
1183
1184
:param line_iterator: An iterator of lines, origin_version_id
1185
:return: A dictionary mapping text keys ((fileid, revision_id) tuples)
1186
to whether they were referred to by the inventory of the
1187
revision_id that they contain. Note that if that revision_id was
1188
not part of the line_iterator's output then False will be given -
1189
even though it may actually refer to that key.
1190
"""
1191
if not self._serializer.support_altered_by_hack:
1192
raise AssertionError(
1193
"_find_text_key_references_from_xml_inventory_lines only "
1194
"supported for branches which store inventory as unnested xml"
1195
", not on %r" % self)
1196
558
result = {}
1197
559
1198
560
# this code needs to read every new line in every inventory for the
1214
576
search = self._file_ids_altered_regex.search
1215
577
unescape = _unescape_xml
1216
578
setdefault = result.setdefault
1217
for line, version_id in line_iterator:
1218
match = search(line)
1219
if match is None:
1220
continue
1221
# One call to match.group() returning multiple items is quite a
1222
# bit faster than 2 calls to match.group() each returning 1
1223
file_id, revision_id = match.group('file_id', 'revision_id')
1224
1225
# Inlining the cache lookups helps a lot when you make 170,000
1226
# lines and 350k ids, versus 8.4 unique ids.
1227
# Using a cache helps in 2 ways:
1228
# 1) Avoids unnecessary decoding calls
1229
# 2) Re-uses cached strings, which helps in future set and
1230
# equality checks.
1231
# (2) is enough that removing encoding entirely along with
1232
# the cache (so we are using plain strings) results in no
1233
# performance improvement.
1234
try:
1235
revision_id = unescape_revid_cache[revision_id]
1236
except KeyError:
1237
unescaped = unescape(revision_id)
1238
unescape_revid_cache[revision_id] = unescaped
1239
revision_id = unescaped
1240
1241
# Note that unconditionally unescaping means that we deserialise
1242
# every fileid, which for general 'pull' is not great, but we don't
1243
# really want to have some many fulltexts that this matters anyway.
1244
# RBC 20071114.
1245
try:
1246
file_id = unescape_fileid_cache[file_id]
1247
except KeyError:
1248
unescaped = unescape(file_id)
1249
unescape_fileid_cache[file_id] = unescaped
1250
file_id = unescaped
1251
1252
key = (file_id, revision_id)
1253
setdefault(key, False)
1254
if revision_id == version_id:
1255
result[key] = True
1256
return result
1257
1258
def _find_file_ids_from_xml_inventory_lines(self, line_iterator,
1259
revision_ids):
1260
"""Helper routine for fileids_altered_by_revision_ids.
1261
1262
This performs the translation of xml lines to revision ids.
1263
1264
:param line_iterator: An iterator of lines, origin_version_id
1265
:param revision_ids: The revision ids to filter for. This should be a
1266
set or other type which supports efficient __contains__ lookups, as
1267
the revision id from each parsed line will be looked up in the
1268
revision_ids filter.
1269
:return: a dictionary mapping altered file-ids to an iterable of
1270
revision_ids. Each altered file-ids has the exact revision_ids that
1271
altered it listed explicitly.
1272
"""
1273
result = {}
1274
setdefault = result.setdefault
1275
for file_id, revision_id in \
1276
self._find_text_key_references_from_xml_inventory_lines(
1277
line_iterator).iterkeys():
1278
# once data is all ensured-consistent; then this is
1279
# if revision_id == version_id
1280
if revision_id in revision_ids:
1281
setdefault(file_id, set()).add(revision_id)
1282
return result
1283
1284
def fileids_altered_by_revision_ids(self, revision_ids):
1285
"""Find the file ids and versions affected by revisions.
1286
1287
:param revisions: an iterable containing revision ids.
1288
:return: a dictionary mapping altered file-ids to an iterable of
1289
revision_ids. Each altered file-ids has the exact revision_ids that
1290
altered it listed explicitly.
1291
"""
1292
selected_revision_ids = set(revision_ids)
1293
w = self.get_inventory_weave()
1294
pb = ui.ui_factory.nested_progress_bar()
1295
try:
1296
return self._find_file_ids_from_xml_inventory_lines(
1297
w.iter_lines_added_or_present_in_versions(
1298
selected_revision_ids, pb=pb),
1299
selected_revision_ids)
1300
finally:
1301
pb.finished()
1302
1303
def iter_files_bytes(self, desired_files):
1304
"""Iterate through file versions.
1305
1306
Files will not necessarily be returned in the order they occur in
1307
desired_files. No specific order is guaranteed.
1308
1309
Yields pairs of identifier, bytes_iterator. identifier is an opaque
1310
value supplied by the caller as part of desired_files. It should
1311
uniquely identify the file version in the caller's context. (Examples:
1312
an index number or a TreeTransform trans_id.)
1313
1314
bytes_iterator is an iterable of bytestrings for the file. The
1315
kind of iterable and length of the bytestrings are unspecified, but for
1316
this implementation, it is a list of lines produced by
1317
VersionedFile.get_lines().
1318
1319
:param desired_files: a list of (file_id, revision_id, identifier)
1320
triples
1321
"""
1322
transaction = self.get_transaction()
1323
for file_id, revision_id, callable_data in desired_files:
1324
try:
1325
weave = self.weave_store.get_weave(file_id, transaction)
1326
except errors.NoSuchFile:
1327
raise errors.NoSuchIdInRepository(self, file_id)
1328
yield callable_data, weave.get_lines(revision_id)
1329
1330
def _generate_text_key_index(self, text_key_references=None,
1331
ancestors=None):
1332
"""Generate a new text key index for the repository.
1333
1334
This is an expensive function that will take considerable time to run.
1335
1336
:return: A dict mapping text keys ((file_id, revision_id) tuples) to a
1337
list of parents, also text keys. When a given key has no parents,
1338
the parents list will be [NULL_REVISION].
1339
"""
1340
# All revisions, to find inventory parents.
1341
if ancestors is None:
1342
graph = self.get_graph()
1343
ancestors = graph.get_parent_map(self.all_revision_ids())
1344
if text_key_references is None:
1345
text_key_references = self.find_text_key_references()
1346
pb = ui.ui_factory.nested_progress_bar()
1347
try:
1348
return self._do_generate_text_key_index(ancestors,
1349
text_key_references, pb)
1350
finally:
1351
pb.finished()
1352
1353
def _do_generate_text_key_index(self, ancestors, text_key_references, pb):
1354
"""Helper for _generate_text_key_index to avoid deep nesting."""
1355
revision_order = tsort.topo_sort(ancestors)
1356
invalid_keys = set()
1357
revision_keys = {}
1358
for revision_id in revision_order:
1359
revision_keys[revision_id] = set()
1360
text_count = len(text_key_references)
1361
# a cache of the text keys to allow reuse; costs a dict of all the
1362
# keys, but saves a 2-tuple for every child of a given key.
1363
text_key_cache = {}
1364
for text_key, valid in text_key_references.iteritems():
1365
if not valid:
1366
invalid_keys.add(text_key)
1367
else:
1368
revision_keys[text_key[1]].add(text_key)
1369
text_key_cache[text_key] = text_key
1370
del text_key_references
1371
text_index = {}
1372
text_graph = graph.Graph(graph.DictParentsProvider(text_index))
1373
NULL_REVISION = _mod_revision.NULL_REVISION
1374
# Set a cache with a size of 10 - this suffices for bzr.dev but may be
1375
# too small for large or very branchy trees. However, for 55K path
1376
# trees, it would be easy to use too much memory trivially. Ideally we
1377
# could gauge this by looking at available real memory etc, but this is
1378
# always a tricky proposition.
1379
inventory_cache = lru_cache.LRUCache(10)
1380
batch_size = 10 # should be ~150MB on a 55K path tree
1381
batch_count = len(revision_order) / batch_size + 1
1382
processed_texts = 0
1383
pb.update("Calculating text parents.", processed_texts, text_count)
1384
for offset in xrange(batch_count):
1385
to_query = revision_order[offset * batch_size:(offset + 1) *
1386
batch_size]
1387
if not to_query:
1388
break
1389
for rev_tree in self.revision_trees(to_query):
1390
revision_id = rev_tree.get_revision_id()
1391
parent_ids = ancestors[revision_id]
1392
for text_key in revision_keys[revision_id]:
1393
pb.update("Calculating text parents.", processed_texts)
1394
processed_texts += 1
1395
candidate_parents = []
1396
for parent_id in parent_ids:
1397
parent_text_key = (text_key[0], parent_id)
1398
try:
1399
check_parent = parent_text_key not in \
1400
revision_keys[parent_id]
1401
except KeyError:
1402
# the parent parent_id is a ghost:
1403
check_parent = False
1404
# truncate the derived graph against this ghost.
1405
parent_text_key = None
1406
if check_parent:
1407
# look at the parent commit details inventories to
1408
# determine possible candidates in the per file graph.
1409
# TODO: cache here.
1410
try:
1411
inv = inventory_cache[parent_id]
1412
except KeyError:
1413
inv = self.revision_tree(parent_id).inventory
1414
inventory_cache[parent_id] = inv
1415
parent_entry = inv._byid.get(text_key[0], None)
1416
if parent_entry is not None:
1417
parent_text_key = (
1418
text_key[0], parent_entry.revision)
1419
else:
1420
parent_text_key = None
1421
if parent_text_key is not None:
1422
candidate_parents.append(
1423
text_key_cache[parent_text_key])
1424
parent_heads = text_graph.heads(candidate_parents)
1425
new_parents = list(parent_heads)
1426
new_parents.sort(key=lambda x:candidate_parents.index(x))
1427
if new_parents == []:
1428
new_parents = [NULL_REVISION]
1429
text_index[text_key] = new_parents
1430
1431
for text_key in invalid_keys:
1432
text_index[text_key] = [NULL_REVISION]
1433
return text_index
1434
1435
def item_keys_introduced_by(self, revision_ids, _files_pb=None):
1436
"""Get an iterable listing the keys of all the data introduced by a set
1437
of revision IDs.
1438
1439
The keys will be ordered so that the corresponding items can be safely
1440
fetched and inserted in that order.
1441
1442
:returns: An iterable producing tuples of (knit-kind, file-id,
1443
versions). knit-kind is one of 'file', 'inventory', 'signatures',
1444
'revisions'. file-id is None unless knit-kind is 'file'.
1445
"""
1446
# XXX: it's a bit weird to control the inventory weave caching in this
1447
# generator. Ideally the caching would be done in fetch.py I think. Or
1448
# maybe this generator should explicitly have the contract that it
1449
# should not be iterated until the previously yielded item has been
1450
# processed?
1451
self.lock_read()
1452
inv_w = self.get_inventory_weave()
1453
inv_w.enable_cache()
1454
1455
# file ids that changed
1456
file_ids = self.fileids_altered_by_revision_ids(revision_ids)
1457
count = 0
1458
num_file_ids = len(file_ids)
1459
for file_id, altered_versions in file_ids.iteritems():
1460
if _files_pb is not None:
1461
_files_pb.update("fetch texts", count, num_file_ids)
1462
count += 1
1463
yield ("file", file_id, altered_versions)
1464
# We're done with the files_pb. Note that it finished by the caller,
1465
# just as it was created by the caller.
1466
del _files_pb
1467
1468
# inventory
1469
yield ("inventory", None, revision_ids)
1470
inv_w.clear_cache()
1471
1472
# signatures
1473
revisions_with_signatures = set()
1474
for rev_id in revision_ids:
1475
try:
1476
self.get_signature_text(rev_id)
1477
except errors.NoSuchRevision:
1478
# not signed.
1479
pass
1480
else:
1481
revisions_with_signatures.add(rev_id)
1482
self.unlock()
1483
yield ("signatures", None, revisions_with_signatures)
1484
1485
# revisions
1486
yield ("revisions", None, revision_ids)
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()
616
return result
1487
617
1488
618
@needs_read_lock
1489
619
def get_inventory_weave(self):
1492
622
1493
623
@needs_read_lock
1494
624
def get_inventory(self, revision_id):
1495
"""Get Inventory object by revision id."""
1496
return self.iter_inventories([revision_id]).next()
1497
1498
def iter_inventories(self, revision_ids):
1499
"""Get many inventories by revision_ids.
1500
1501
This will buffer some or all of the texts used in constructing the
1502
inventories in memory, but will only parse a single inventory at a
1503
time.
1504
1505
:return: An iterator of inventories.
1506
"""
1507
assert None not in revision_ids
1508
assert _mod_revision.NULL_REVISION not in revision_ids
1509
return self._iter_inventories(revision_ids)
1510
1511
def _iter_inventories(self, revision_ids):
1512
"""single-document based inventory iteration."""
1513
texts = self.get_inventory_weave().get_texts(revision_ids)
1514
for text, revision_id in zip(texts, revision_ids):
1515
yield self.deserialise_inventory(revision_id, text)
625
"""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))
1516
631
1517
632
def deserialise_inventory(self, revision_id, xml):
1518
633
"""Transform the xml into an inventory object.
1520
635
:param revision_id: The expected revision id of the inventory.
1521
636
:param xml: A serialised inventory.
1522
637
"""
1523
result = self._serializer.read_inventory_from_string(xml, revision_id)
1524
if result.revision_id != revision_id:
1525
raise AssertionError('revision id mismatch %s != %s' % (
1526
result.revision_id, revision_id))
638
revision_id = osutils.safe_revision_id(revision_id)
639
result = self._serializer.read_inventory_from_string(xml)
640
result.root.revision = revision_id
1527
641
return result
1528
642
1529
643
def serialise_inventory(self, inv):
1530
644
return self._serializer.write_inventory_to_string(inv)
1531
645
1532
def _serialise_inventory_to_lines(self, inv):
1533
return self._serializer.write_inventory_to_lines(inv)
1534
1535
def get_serializer_format(self):
1536
return self._serializer.format_num
1537
1538
646
@needs_read_lock
1539
647
def get_inventory_xml(self, revision_id):
1540
648
"""Get inventory XML as a file object."""
649
revision_id = osutils.safe_revision_id(revision_id)
1541
650
try:
1542
651
assert isinstance(revision_id, str), type(revision_id)
1543
652
iw = self.get_inventory_weave()
1549
658
def get_inventory_sha1(self, revision_id):
1550
659
"""Return the sha1 hash of the inventory entry
1551
660
"""
661
# TODO: jam 20070210 Shouldn't this be deprecated / removed?
662
revision_id = osutils.safe_revision_id(revision_id)
1552
663
return self.get_revision(revision_id).inventory_sha1
1553
664
1554
665
@needs_read_lock
1555
@deprecated_method(symbol_versioning.one_four)
1556
666
def get_revision_graph(self, revision_id=None):
1557
667
"""Return a dictionary containing the revision graph.
1558
1559
NB: This method should not be used as it accesses the entire graph all
1560
at once, which is much more data than most operations should require.
1561
668
1562
669
:param revision_id: The revision_id to get a graph from. If None, then
1563
670
the entire revision graph is returned. This is a deprecated mode of
1564
671
operation and will be removed in the future.
1565
672
:return: a dictionary of revision_id->revision_parents_list.
1566
673
"""
1567
raise NotImplementedError(self.get_revision_graph)
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
682
node in all_revisions])
683
if revision_id is None:
684
return entire_graph
685
elif revision_id not in entire_graph:
686
raise errors.NoSuchRevision(self, revision_id)
687
else:
688
# add what can be reached from revision_id
689
result = {}
690
pending = set([revision_id])
691
while len(pending) > 0:
692
node = pending.pop()
693
result[node] = entire_graph[node]
694
for revision_id in result[node]:
695
if revision_id not in result:
696
pending.add(revision_id)
697
return result
1568
698
1569
699
@needs_read_lock
1570
@deprecated_method(symbol_versioning.one_three)
1571
700
def get_revision_graph_with_ghosts(self, revision_ids=None):
1572
701
"""Return a graph of the revisions with ghosts marked as applicable.
1573
702
1574
703
:param revision_ids: an iterable of revisions to graph or None for all.
1575
704
:return: a Graph object with the graph reachable from revision_ids.
1576
705
"""
1577
if 'evil' in debug.debug_flags:
1578
mutter_callsite(3,
1579
"get_revision_graph_with_ghosts scales with size of history.")
1580
result = deprecated_graph.Graph()
706
result = graph.Graph()
1581
707
if not revision_ids:
1582
708
pending = set(self.all_revision_ids())
1583
709
required = set([])
1584
710
else:
1585
pending = set(revision_ids)
711
pending = set(osutils.safe_revision_id(r) for r in revision_ids)
1586
712
# special case NULL_REVISION
1587
713
if _mod_revision.NULL_REVISION in pending:
1588
714
pending.remove(_mod_revision.NULL_REVISION)
1608
734
done.add(revision_id)
1609
735
return result
1610
736
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
1611
744
def iter_reverse_revision_history(self, revision_id):
1612
745
"""Iterate backwards through revision ids in the lefthand history
1613
746
1614
747
:param revision_id: The revision id to start with. All its lefthand
1615
748
ancestors will be traversed.
1616
749
"""
1617
graph = self.get_graph()
750
revision_id = osutils.safe_revision_id(revision_id)
751
if revision_id in (None, _mod_revision.NULL_REVISION):
752
return
1618
753
next_id = revision_id
754
versionedfile = self._get_history_vf()
1619
755
while True:
1620
if next_id in (None, _mod_revision.NULL_REVISION):
1621
return
1622
756
yield next_id
1623
# Note: The following line may raise KeyError in the event of
1624
# truncated history. We decided not to have a try:except:raise
1625
# RevisionNotPresent here until we see a use for it, because of the
1626
# cost in an inner loop that is by its very nature O(history).
1627
# Robert Collins 20080326
1628
parents = graph.get_parent_map([next_id])[next_id]
757
parents = versionedfile.get_parents(next_id)
1629
758
if len(parents) == 0:
1630
759
return
1631
760
else:
1660
789
reconciler.reconcile()
1661
790
return reconciler
1662
791
1663
def _refresh_data(self):
1664
"""Helper called from lock_* to ensure coherency with disk.
1665
1666
The default implementation does nothing; it is however possible
1667
for repositories to maintain loaded indices across multiple locks
1668
by checking inside their implementation of this method to see
1669
whether their indices are still valid. This depends of course on
1670
the disk format being validatable in this manner.
1671
"""
1672
1673
792
@needs_read_lock
1674
793
def revision_tree(self, revision_id):
1675
794
"""Return Tree for a revision on this branch.
1682
801
return RevisionTree(self, Inventory(root_id=None),
1683
802
_mod_revision.NULL_REVISION)
1684
803
else:
804
revision_id = osutils.safe_revision_id(revision_id)
1685
805
inv = self.get_revision_inventory(revision_id)
1686
806
return RevisionTree(self, inv, revision_id)
1687
807
1690
810
"""Return Tree for a revision on this branch.
1691
811
1692
812
`revision_id` may not be None or 'null:'"""
1693
inventories = self.iter_inventories(revision_ids)
1694
for inv in inventories:
1695
yield RevisionTree(self, inv, inv.revision_id)
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)
1696
819
1697
820
@needs_read_lock
1698
def get_ancestry(self, revision_id, topo_sorted=True):
821
def get_ancestry(self, revision_id):
1699
822
"""Return a list of revision-ids integrated by a revision.
1700
823
1701
824
The first element of the list is always None, indicating the origin
1704
827
1705
828
This is topologically sorted.
1706
829
"""
1707
if _mod_revision.is_null(revision_id):
830
if revision_id is None:
1708
831
return [None]
832
revision_id = osutils.safe_revision_id(revision_id)
1709
833
if not self.has_revision(revision_id):
1710
834
raise errors.NoSuchRevision(self, revision_id)
1711
835
w = self.get_inventory_weave()
1712
candidates = w.get_ancestry(revision_id, topo_sorted)
836
candidates = w.get_ancestry(revision_id)
1713
837
return [None] + candidates # self._eliminate_revisions_not_present(candidates)
1714
838
1715
def pack(self):
1716
"""Compress the data within the repository.
1717
1718
This operation only makes sense for some repository types. For other
1719
types it should be a no-op that just returns.
1720
1721
This stub method does not require a lock, but subclasses should use
1722
@needs_write_lock as this is a long running call its reasonable to
1723
implicitly lock for the user.
1724
"""
1725
1726
839
@needs_read_lock
1727
840
def print_file(self, file, revision_id):
1728
841
"""Print `file` to stdout.
1731
844
- it writes to stdout, it assumes that that is valid etc. Fix
1732
845
by creating a new more flexible convenience function.
1733
846
"""
847
revision_id = osutils.safe_revision_id(revision_id)
1734
848
tree = self.revision_tree(revision_id)
1735
849
# use inventory as it was in that revision
1736
850
file_id = tree.inventory.path2id(file)
1745
859
return self.control_files.get_transaction()
1746
860
1747
861
def revision_parents(self, revision_id):
862
revision_id = osutils.safe_revision_id(revision_id)
1748
863
return self.get_inventory_weave().parent_names(revision_id)
1749
864
1750
@deprecated_method(symbol_versioning.one_one)
1751
def get_parents(self, revision_ids):
1752
"""See StackedParentsProvider.get_parents"""
1753
parent_map = self.get_parent_map(revision_ids)
1754
return [parent_map.get(r, None) for r in revision_ids]
1755
1756
def get_parent_map(self, keys):
1757
"""See graph._StackedParentsProvider.get_parent_map"""
1758
parent_map = {}
1759
for revision_id in keys:
1760
if revision_id == _mod_revision.NULL_REVISION:
1761
parent_map[revision_id] = ()
1762
else:
1763
try:
1764
parent_id_list = self.get_revision(revision_id).parent_ids
1765
except errors.NoSuchRevision:
1766
pass
1767
else:
1768
if len(parent_id_list) == 0:
1769
parent_ids = (_mod_revision.NULL_REVISION,)
1770
else:
1771
parent_ids = tuple(parent_id_list)
1772
parent_map[revision_id] = parent_ids
1773
return parent_map
1774
1775
def _make_parents_provider(self):
1776
return self
1777
1778
def get_graph(self, other_repository=None):
1779
"""Return the graph walker for this repository format"""
1780
parents_provider = self._make_parents_provider()
1781
if (other_repository is not None and
1782
not self.has_same_location(other_repository)):
1783
parents_provider = graph._StackedParentsProvider(
1784
[parents_provider, other_repository._make_parents_provider()])
1785
return graph.Graph(parents_provider)
1786
1787
def _get_versioned_file_checker(self):
1788
"""Return an object suitable for checking versioned files."""
1789
return _VersionedFileChecker(self)
1790
1791
def revision_ids_to_search_result(self, result_set):
1792
"""Convert a set of revision ids to a graph SearchResult."""
1793
result_parents = set()
1794
for parents in self.get_graph().get_parent_map(
1795
result_set).itervalues():
1796
result_parents.update(parents)
1797
included_keys = result_set.intersection(result_parents)
1798
start_keys = result_set.difference(included_keys)
1799
exclude_keys = result_parents.difference(result_set)
1800
result = graph.SearchResult(start_keys, exclude_keys,
1801
len(result_set), result_set)
1802
return result
1803
1804
865
@needs_write_lock
1805
866
def set_make_working_trees(self, new_value):
1806
867
"""Set the policy flag for making working trees when creating branches.
1819
880
1820
881
@needs_write_lock
1821
882
def sign_revision(self, revision_id, gpg_strategy):
883
revision_id = osutils.safe_revision_id(revision_id)
1822
884
plaintext = Testament.from_revision(self, revision_id).as_short_text()
1823
885
self.store_revision_signature(gpg_strategy, plaintext, revision_id)
1824
886
1825
887
@needs_read_lock
1826
888
def has_signature_for_revision_id(self, revision_id):
1827
889
"""Query for a revision signature for revision_id in the repository."""
890
revision_id = osutils.safe_revision_id(revision_id)
1828
891
return self._revision_store.has_signature(revision_id,
1829
892
self.get_transaction())
1830
893
1831
894
@needs_read_lock
1832
895
def get_signature_text(self, revision_id):
1833
896
"""Return the text for a signature."""
897
revision_id = osutils.safe_revision_id(revision_id)
1834
898
return self._revision_store.get_signature_text(revision_id,
1835
899
self.get_transaction())
1836
900
1837
901
@needs_read_lock
1838
def check(self, revision_ids=None):
902
def check(self, revision_ids):
1839
903
"""Check consistency of all history of given revision_ids.
1840
904
1841
905
Different repository implementations should override _check().
1843
907
:param revision_ids: A non-empty list of revision_ids whose ancestry
1844
908
will be checked. Typically the last revision_id of a branch.
1845
909
"""
910
if not revision_ids:
911
raise ValueError("revision_ids must be non-empty in %s.check"
912
% (self,))
913
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
1846
914
return self._check(revision_ids)
1847
915
1848
916
def _check(self, revision_ids):
1876
944
revision_id.decode('ascii')
1877
945
except UnicodeDecodeError:
1878
946
raise errors.NonAsciiRevisionId(method, self)
1879
1880
def revision_graph_can_have_wrong_parents(self):
1881
"""Is it possible for this repository to have a revision graph with
1882
incorrect parents?
1883
947
1884
If True, then this repository must also implement
1885
_find_inconsistent_revision_parents so that check and reconcile can
1886
check for inconsistencies before proceeding with other checks that may
1887
depend on the revision index being consistent.
1888
"""
1889
raise NotImplementedError(self.revision_graph_can_have_wrong_parents)
1890
948
1891
949
1892
950
# remove these delegates a while after bzr 0.15
1925
983
1926
984
def install_revision(repository, rev, revision_tree):
1927
985
"""Install all revision data into a repository."""
1928
install_revisions(repository, [(rev, revision_tree, None)])
1929
1930
1931
def install_revisions(repository, iterable, num_revisions=None, pb=None):
1932
"""Install all revision data into a repository.
1933
1934
Accepts an iterable of revision, tree, signature tuples. The signature
1935
may be None.
1936
"""
1937
repository.start_write_group()
1938
try:
1939
for n, (revision, revision_tree, signature) in enumerate(iterable):
1940
_install_revision(repository, revision, revision_tree, signature)
1941
if pb is not None:
1942
pb.update('Transferring revisions', n + 1, num_revisions)
1943
except:
1944
repository.abort_write_group()
1945
raise
1946
else:
1947
repository.commit_write_group()
1948
1949
1950
def _install_revision(repository, rev, revision_tree, signature):
1951
"""Install all revision data into a repository."""
1952
986
present_parents = []
1953
987
parent_trees = {}
1954
988
for p_id in rev.parent_ids:
1960
994
1961
995
inv = revision_tree.inventory
1962
996
entries = inv.iter_entries()
1963
# backwards compatibility hack: skip the root id.
997
# backwards compatability hack: skip the root id.
1964
998
if not repository.supports_rich_root():
1965
999
path, root = entries.next()
1966
1000
if root.revision != rev.revision_id:
1992
1026
repository.add_inventory(rev.revision_id, inv, present_parents)
1993
1027
except errors.RevisionAlreadyPresent:
1994
1028
pass
1995
if signature is not None:
1996
repository.add_signature_text(rev.revision_id, signature)
1997
1029
repository.add_revision(rev.revision_id, rev, inv)
1998
1030
1999
1031
2039
1071
2040
1072
2041
1073
class RepositoryFormatRegistry(registry.Registry):
2042
"""Registry of RepositoryFormats."""
1074
"""Registry of RepositoryFormats.
1075
"""
2043
1076
2044
1077
def get(self, format_string):
2045
1078
r = registry.Registry.get(self, format_string)
2068
1101
children.
2069
1102
* an open routine which returns a Repository instance.
2070
1103
2071
There is one and only one Format subclass for each on-disk format. But
2072
there can be one Repository subclass that is used for several different
2073
formats. The _format attribute on a Repository instance can be used to
2074
determine the disk format.
2075
2076
1104
Formats are placed in an dict by their format string for reference
2077
1105
during opening. These should be subclasses of RepositoryFormat
2078
1106
for consistency.
2085
1113
_matchingbzrdir - the bzrdir format that the repository format was
2086
1114
originally written to work with. This can be used if manually
2087
1115
constructing a bzrdir and repository, or more commonly for test suite
2088
parameterization.
1116
parameterisation.
2089
1117
"""
2090
1118
2091
# Set to True or False in derived classes. True indicates that the format
2092
# supports ghosts gracefully.
2093
supports_ghosts = None
2094
# Can this repository be given external locations to lookup additional
2095
# data. Set to True or False in derived classes.
2096
supports_external_lookups = None
2097
2098
1119
def __str__(self):
2099
1120
return "<%s>" % self.__class__.__name__
2100
1121
2120
1141
except errors.NoSuchFile:
2121
1142
raise errors.NoRepositoryPresent(a_bzrdir)
2122
1143
except KeyError:
2123
raise errors.UnknownFormatError(format=format_string,
2124
kind='repository')
1144
raise errors.UnknownFormatError(format=format_string)
2125
1145
2126
1146
@classmethod
2127
1147
def register_format(klass, format):
2239
1259
2240
1260
rich_root_data = False
2241
1261
supports_tree_reference = False
2242
supports_external_lookups = False
2243
1262
_matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2244
1263
2245
1264
def __init__(self):
2283
1302
'bzrlib.repofmt.weaverepo',
2284
1303
'RepositoryFormat7'
2285
1304
)
1305
# KEEP in sync with bzrdir.format_registry default, which controls the overall
1306
# default control directory format
2286
1307
2287
1308
format_registry.register_lazy(
2288
1309
'Bazaar-NG Knit Repository Format 1',
2289
1310
'bzrlib.repofmt.knitrepo',
2290
1311
'RepositoryFormatKnit1',
2291
1312
)
1313
format_registry.default_key = 'Bazaar-NG Knit Repository Format 1'
2292
1314
2293
1315
format_registry.register_lazy(
2294
1316
'Bazaar Knit Repository Format 3 (bzr 0.15)\n',
2296
1318
'RepositoryFormatKnit3',
2297
1319
)
2298
1320
2299
format_registry.register_lazy(
2300
'Bazaar Knit Repository Format 4 (bzr 1.0)\n',
2301
'bzrlib.repofmt.knitrepo',
2302
'RepositoryFormatKnit4',
2303
)
2304
2305
# Pack-based formats. There is one format for pre-subtrees, and one for
2306
# post-subtrees to allow ease of testing.
2307
# NOTE: These are experimental in 0.92. Stable in 1.0 and above
2308
format_registry.register_lazy(
2309
'Bazaar pack repository format 1 (needs bzr 0.92)\n',
2310
'bzrlib.repofmt.pack_repo',
2311
'RepositoryFormatKnitPack1',
2312
)
2313
format_registry.register_lazy(
2314
'Bazaar pack repository format 1 with subtree support (needs bzr 0.92)\n',
2315
'bzrlib.repofmt.pack_repo',
2316
'RepositoryFormatKnitPack3',
2317
)
2318
format_registry.register_lazy(
2319
'Bazaar pack repository format 1 with rich root (needs bzr 1.0)\n',
2320
'bzrlib.repofmt.pack_repo',
2321
'RepositoryFormatKnitPack4',
2322
)
2323
# Development formats.
2324
# 1.2->1.3
2325
# development 0 - stub to introduce development versioning scheme.
2326
format_registry.register_lazy(
2327
"Bazaar development format 0 (needs bzr.dev from before 1.3)\n",
2328
'bzrlib.repofmt.pack_repo',
2329
'RepositoryFormatPackDevelopment0',
2330
)
2331
format_registry.register_lazy(
2332
("Bazaar development format 0 with subtree support "
2333
"(needs bzr.dev from before 1.3)\n"),
2334
'bzrlib.repofmt.pack_repo',
2335
'RepositoryFormatPackDevelopment0Subtree',
2336
)
2337
# 1.3->1.4 go below here
2338
2339
1321
2340
1322
class InterRepository(InterObject):
2341
1323
"""This class represents operations taking place between two repositories.
2355
1337
def copy_content(self, revision_id=None):
2356
1338
raise NotImplementedError(self.copy_content)
2357
1339
2358
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1340
def fetch(self, revision_id=None, pb=None):
2359
1341
"""Fetch the content required to construct revision_id.
2360
1342
2361
1343
The content is copied from self.source to self.target.
2369
1351
(copied, failures).
2370
1352
"""
2371
1353
raise NotImplementedError(self.fetch)
2372
2373
def _walk_to_common_revisions(self, revision_ids):
2374
"""Walk out from revision_ids in source to revisions target has.
2375
2376
:param revision_ids: The start point for the search.
2377
:return: A set of revision ids.
2378
"""
2379
graph = self.source.get_graph()
2380
missing_revs = set()
2381
# ensure we don't pay silly lookup costs.
2382
revision_ids = frozenset(revision_ids)
2383
searcher = graph._make_breadth_first_searcher(revision_ids)
2384
null_set = frozenset([_mod_revision.NULL_REVISION])
2385
while True:
2386
try:
2387
next_revs, ghosts = searcher.next_with_ghosts()
2388
except StopIteration:
2389
break
2390
if revision_ids.intersection(ghosts):
2391
absent_ids = set(revision_ids.intersection(ghosts))
2392
# If all absent_ids are present in target, no error is needed.
2393
absent_ids.difference_update(
2394
self.target.has_revisions(absent_ids))
2395
if absent_ids:
2396
raise errors.NoSuchRevision(self.source, absent_ids.pop())
2397
# we don't care about other ghosts as we can't fetch them and
2398
# haven't been asked to.
2399
next_revs = set(next_revs)
2400
# we always have NULL_REVISION present.
2401
have_revs = self.target.has_revisions(next_revs).union(null_set)
2402
missing_revs.update(next_revs - have_revs)
2403
searcher.stop_searching_any(have_revs)
2404
return searcher.get_result()
2405
1354
2406
@deprecated_method(symbol_versioning.one_two)
2407
1355
@needs_read_lock
2408
def missing_revision_ids(self, revision_id=None, find_ghosts=True):
1356
def missing_revision_ids(self, revision_id=None):
2409
1357
"""Return the revision ids that source has that target does not.
2410
1358
2411
1359
These are returned in topological order.
2412
1360
2413
1361
:param revision_id: only return revision ids included by this
2414
1362
revision_id.
2415
:param find_ghosts: If True find missing revisions in deep history
2416
rather than just finding the surface difference.
2417
"""
2418
return list(self.search_missing_revision_ids(
2419
revision_id, find_ghosts).get_keys())
2420
2421
@needs_read_lock
2422
def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2423
"""Return the revision ids that source has that target does not.
2424
2425
:param revision_id: only return revision ids included by this
2426
revision_id.
2427
:param find_ghosts: If True find missing revisions in deep history
2428
rather than just finding the surface difference.
2429
:return: A bzrlib.graph.SearchResult.
2430
"""
2431
# stop searching at found target revisions.
2432
if not find_ghosts and revision_id is not None:
2433
return self._walk_to_common_revisions([revision_id])
1363
"""
2434
1364
# generic, possibly worst case, slow code path.
2435
1365
target_ids = set(self.target.all_revision_ids())
2436
1366
if revision_id is not None:
1367
# TODO: jam 20070210 InterRepository is internal enough that it
1368
# should assume revision_ids are already utf-8
1369
revision_id = osutils.safe_revision_id(revision_id)
2437
1370
source_ids = self.source.get_ancestry(revision_id)
2438
1371
assert source_ids[0] is None
2439
1372
source_ids.pop(0)
2440
1373
else:
2441
1374
source_ids = self.source.all_revision_ids()
2442
1375
result_set = set(source_ids).difference(target_ids)
2443
return self.source.revision_ids_to_search_result(result_set)
2444
2445
@staticmethod
2446
def _same_model(source, target):
2447
"""True if source and target have the same data representation."""
2448
if source.supports_rich_root() != target.supports_rich_root():
2449
return False
2450
if source._serializer != target._serializer:
2451
return False
2452
return True
1376
# this may look like a no-op: its not. It preserves the ordering
1377
# other_ids had while only returning the members from other_ids
1378
# that we've decided we need.
1379
return [rev_id for rev_id in source_ids if rev_id in result_set]
2453
1380
2454
1381
2455
1382
class InterSameDataRepository(InterRepository):
2460
1387
2461
1388
@classmethod
2462
1389
def _get_repo_format_to_test(self):
2463
"""Repository format for testing with.
2464
2465
InterSameData can pull from subtree to subtree and from non-subtree to
2466
non-subtree, so we test this with the richest repository format.
2467
"""
2468
from bzrlib.repofmt import knitrepo
2469
return knitrepo.RepositoryFormatKnit3()
1390
"""Repository format for testing with."""
1391
return RepositoryFormat.get_default_format()
2470
1392
2471
1393
@staticmethod
2472
1394
def is_compatible(source, target):
2473
return InterRepository._same_model(source, target)
1395
if source.supports_rich_root() != target.supports_rich_root():
1396
return False
1397
if source._serializer != target._serializer:
1398
return False
1399
return True
2474
1400
2475
1401
@needs_write_lock
2476
1402
def copy_content(self, revision_id=None):
2489
1415
self.target.set_make_working_trees(self.source.make_working_trees())
2490
1416
except NotImplementedError:
2491
1417
pass
1418
# TODO: jam 20070210 This is fairly internal, so we should probably
1419
# just assert that revision_id is not unicode.
1420
revision_id = osutils.safe_revision_id(revision_id)
2492
1421
# but don't bother fetching if we have the needed data now.
2493
1422
if (revision_id not in (None, _mod_revision.NULL_REVISION) and
2494
1423
self.target.has_revision(revision_id)):
2496
1425
self.target.fetch(self.source, revision_id=revision_id)
2497
1426
2498
1427
@needs_write_lock
2499
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1428
def fetch(self, revision_id=None, pb=None):
2500
1429
"""See InterRepository.fetch()."""
2501
1430
from bzrlib.fetch import GenericRepoFetcher
2502
1431
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2503
self.source, self.source._format, self.target,
1432
self.source, self.source._format, self.target,
2504
1433
self.target._format)
1434
# TODO: jam 20070210 This should be an assert, not a translate
1435
revision_id = osutils.safe_revision_id(revision_id)
2505
1436
f = GenericRepoFetcher(to_repository=self.target,
2506
1437
from_repository=self.source,
2507
1438
last_revision=revision_id,
2508
pb=pb, find_ghosts=find_ghosts)
1439
pb=pb)
2509
1440
return f.count_copied, f.failed_revisions
2510
1441
2511
1442
2512
1443
class InterWeaveRepo(InterSameDataRepository):
2513
"""Optimised code paths between Weave based repositories.
2514
2515
This should be in bzrlib/repofmt/weaverepo.py but we have not yet
2516
implemented lazy inter-object optimisation.
2517
"""
1444
"""Optimised code paths between Weave based repositories."""
2518
1445
2519
1446
@classmethod
2520
1447
def _get_repo_format_to_test(self):
2548
1475
def copy_content(self, revision_id=None):
2549
1476
"""See InterRepository.copy_content()."""
2550
1477
# weave specific optimised path:
1478
# TODO: jam 20070210 Internal, should be an assert, not translate
1479
revision_id = osutils.safe_revision_id(revision_id)
2551
1480
try:
2552
1481
self.target.set_make_working_trees(self.source.make_working_trees())
2553
1482
except NotImplementedError:
2575
1504
self.target.fetch(self.source, revision_id=revision_id)
2576
1505
2577
1506
@needs_write_lock
2578
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1507
def fetch(self, revision_id=None, pb=None):
2579
1508
"""See InterRepository.fetch()."""
2580
1509
from bzrlib.fetch import GenericRepoFetcher
2581
1510
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2582
1511
self.source, self.source._format, self.target, self.target._format)
1512
# TODO: jam 20070210 This should be an assert, not a translate
1513
revision_id = osutils.safe_revision_id(revision_id)
2583
1514
f = GenericRepoFetcher(to_repository=self.target,
2584
1515
from_repository=self.source,
2585
1516
last_revision=revision_id,
2586
pb=pb, find_ghosts=find_ghosts)
1517
pb=pb)
2587
1518
return f.count_copied, f.failed_revisions
2588
1519
2589
1520
@needs_read_lock
2590
def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1521
def missing_revision_ids(self, revision_id=None):
2591
1522
"""See InterRepository.missing_revision_ids()."""
2592
1523
# we want all revisions to satisfy revision_id in source.
2593
1524
# but we don't want to stat every file here and there.
2613
1544
# we do not have a revision as that would be pointless.
2614
1545
target_ids = set(self.target._all_possible_ids())
2615
1546
possibly_present_revisions = target_ids.intersection(source_ids_set)
2616
actually_present_revisions = set(
2617
self.target._eliminate_revisions_not_present(possibly_present_revisions))
1547
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
2618
1548
required_revisions = source_ids_set.difference(actually_present_revisions)
1549
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
2619
1550
if revision_id is not None:
2620
1551
# we used get_ancestry to determine source_ids then we are assured all
2621
1552
# revisions referenced are present as they are installed in topological order.
2622
1553
# and the tip revision was validated by get_ancestry.
2623
result_set = required_revisions
1554
return required_topo_revisions
2624
1555
else:
2625
1556
# if we just grabbed the possibly available ids, then
2626
1557
# we only have an estimate of whats available and need to validate
2627
1558
# that against the revision records.
2628
result_set = set(
2629
self.source._eliminate_revisions_not_present(required_revisions))
2630
return self.source.revision_ids_to_search_result(result_set)
1559
return self.source._eliminate_revisions_not_present(required_topo_revisions)
2631
1560
2632
1561
2633
1562
class InterKnitRepo(InterSameDataRepository):
2646
1575
could lead to confusing results, and there is no need to be
2647
1576
overly general.
2648
1577
"""
2649
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit
1578
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1
2650
1579
try:
2651
are_knits = (isinstance(source._format, RepositoryFormatKnit) and
2652
isinstance(target._format, RepositoryFormatKnit))
1580
return (isinstance(source._format, (RepositoryFormatKnit1)) and
1581
isinstance(target._format, (RepositoryFormatKnit1)))
2653
1582
except AttributeError:
2654
1583
return False
2655
return are_knits and InterRepository._same_model(source, target)
2656
1584
2657
1585
@needs_write_lock
2658
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1586
def fetch(self, revision_id=None, pb=None):
2659
1587
"""See InterRepository.fetch()."""
2660
1588
from bzrlib.fetch import KnitRepoFetcher
2661
1589
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2662
1590
self.source, self.source._format, self.target, self.target._format)
1591
# TODO: jam 20070210 This should be an assert, not a translate
1592
revision_id = osutils.safe_revision_id(revision_id)
2663
1593
f = KnitRepoFetcher(to_repository=self.target,
2664
1594
from_repository=self.source,
2665
1595
last_revision=revision_id,
2666
pb=pb, find_ghosts=find_ghosts)
1596
pb=pb)
2667
1597
return f.count_copied, f.failed_revisions
2668
1598
2669
1599
@needs_read_lock
2670
def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
1600
def missing_revision_ids(self, revision_id=None):
2671
1601
"""See InterRepository.missing_revision_ids()."""
2672
1602
if revision_id is not None:
2673
1603
source_ids = self.source.get_ancestry(revision_id)
2674
1604
assert source_ids[0] is None
2675
1605
source_ids.pop(0)
2676
1606
else:
2677
source_ids = self.source.all_revision_ids()
1607
source_ids = self.source._all_possible_ids()
2678
1608
source_ids_set = set(source_ids)
2679
1609
# source_ids is the worst possible case we may need to pull.
2680
1610
# now we want to filter source_ids against what we actually
2681
1611
# have in target, but don't try to check for existence where we know
2682
1612
# we do not have a revision as that would be pointless.
2683
target_ids = set(self.target.all_revision_ids())
1613
target_ids = set(self.target._all_possible_ids())
2684
1614
possibly_present_revisions = target_ids.intersection(source_ids_set)
2685
actually_present_revisions = set(
2686
self.target._eliminate_revisions_not_present(possibly_present_revisions))
1615
actually_present_revisions = set(self.target._eliminate_revisions_not_present(possibly_present_revisions))
2687
1616
required_revisions = source_ids_set.difference(actually_present_revisions)
1617
required_topo_revisions = [rev_id for rev_id in source_ids if rev_id in required_revisions]
2688
1618
if revision_id is not None:
2689
1619
# we used get_ancestry to determine source_ids then we are assured all
2690
1620
# revisions referenced are present as they are installed in topological order.
2691
1621
# and the tip revision was validated by get_ancestry.
2692
result_set = required_revisions
1622
return required_topo_revisions
2693
1623
else:
2694
1624
# if we just grabbed the possibly available ids, then
2695
1625
# we only have an estimate of whats available and need to validate
2696
1626
# that against the revision records.
2697
result_set = set(
2698
self.source._eliminate_revisions_not_present(required_revisions))
2699
return self.source.revision_ids_to_search_result(result_set)
2700
2701
2702
class InterPackRepo(InterSameDataRepository):
2703
"""Optimised code paths between Pack based repositories."""
2704
2705
@classmethod
2706
def _get_repo_format_to_test(self):
2707
from bzrlib.repofmt import pack_repo
2708
return pack_repo.RepositoryFormatKnitPack1()
2709
2710
@staticmethod
2711
def is_compatible(source, target):
2712
"""Be compatible with known Pack formats.
2713
2714
We don't test for the stores being of specific types because that
2715
could lead to confusing results, and there is no need to be
2716
overly general.
2717
"""
2718
from bzrlib.repofmt.pack_repo import RepositoryFormatPack
2719
try:
2720
are_packs = (isinstance(source._format, RepositoryFormatPack) and
2721
isinstance(target._format, RepositoryFormatPack))
2722
except AttributeError:
2723
return False
2724
return are_packs and InterRepository._same_model(source, target)
2725
2726
@needs_write_lock
2727
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2728
"""See InterRepository.fetch()."""
2729
from bzrlib.repofmt.pack_repo import Packer
2730
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2731
self.source, self.source._format, self.target, self.target._format)
2732
self.count_copied = 0
2733
if revision_id is None:
2734
# TODO:
2735
# everything to do - use pack logic
2736
# to fetch from all packs to one without
2737
# inventory parsing etc, IFF nothing to be copied is in the target.
2738
# till then:
2739
revision_ids = self.source.all_revision_ids()
2740
# implementing the TODO will involve:
2741
# - detecting when all of a pack is selected
2742
# - avoiding as much as possible pre-selection, so the
2743
# more-core routines such as create_pack_from_packs can filter in
2744
# a just-in-time fashion. (though having a HEADS list on a
2745
# repository might make this a lot easier, because we could
2746
# sensibly detect 'new revisions' without doing a full index scan.
2747
elif _mod_revision.is_null(revision_id):
2748
# nothing to do:
2749
return (0, [])
2750
else:
2751
try:
2752
revision_ids = self.search_missing_revision_ids(revision_id,
2753
find_ghosts=find_ghosts).get_keys()
2754
except errors.NoSuchRevision:
2755
raise errors.InstallFailed([revision_id])
2756
packs = self.source._pack_collection.all_packs()
2757
pack = Packer(self.target._pack_collection, packs, '.fetch',
2758
revision_ids).pack()
2759
if pack is not None:
2760
self.target._pack_collection._save_pack_names()
2761
# Trigger an autopack. This may duplicate effort as we've just done
2762
# a pack creation, but for now it is simpler to think about as
2763
# 'upload data, then repack if needed'.
2764
self.target._pack_collection.autopack()
2765
return (pack.get_revision_count(), [])
2766
else:
2767
return (0, [])
2768
2769
@needs_read_lock
2770
def search_missing_revision_ids(self, revision_id=None, find_ghosts=True):
2771
"""See InterRepository.missing_revision_ids().
2772
2773
:param find_ghosts: Find ghosts throughout the ancestry of
2774
revision_id.
2775
"""
2776
if not find_ghosts and revision_id is not None:
2777
return self._walk_to_common_revisions([revision_id])
2778
elif revision_id is not None:
2779
source_ids = self.source.get_ancestry(revision_id)
2780
assert source_ids[0] is None
2781
source_ids.pop(0)
2782
else:
2783
source_ids = self.source.all_revision_ids()
2784
# source_ids is the worst possible case we may need to pull.
2785
# now we want to filter source_ids against what we actually
2786
# have in target, but don't try to check for existence where we know
2787
# we do not have a revision as that would be pointless.
2788
target_ids = set(self.target.all_revision_ids())
2789
result_set = set(source_ids).difference(target_ids)
2790
return self.source.revision_ids_to_search_result(result_set)
1627
return self.source._eliminate_revisions_not_present(required_topo_revisions)
2791
1628
2792
1629
2793
1630
class InterModel1and2(InterRepository):
2804
1641
return False
2805
1642
2806
1643
@needs_write_lock
2807
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1644
def fetch(self, revision_id=None, pb=None):
2808
1645
"""See InterRepository.fetch()."""
2809
1646
from bzrlib.fetch import Model1toKnit2Fetcher
1647
# TODO: jam 20070210 This should be an assert, not a translate
1648
revision_id = osutils.safe_revision_id(revision_id)
2810
1649
f = Model1toKnit2Fetcher(to_repository=self.target,
2811
1650
from_repository=self.source,
2812
1651
last_revision=revision_id,
2813
pb=pb, find_ghosts=find_ghosts)
1652
pb=pb)
2814
1653
return f.count_copied, f.failed_revisions
2815
1654
2816
1655
@needs_write_lock
2827
1666
self.target.set_make_working_trees(self.source.make_working_trees())
2828
1667
except NotImplementedError:
2829
1668
pass
1669
# TODO: jam 20070210 Internal, assert, don't translate
1670
revision_id = osutils.safe_revision_id(revision_id)
2830
1671
# but don't bother fetching if we have the needed data now.
2831
1672
if (revision_id not in (None, _mod_revision.NULL_REVISION) and
2832
1673
self.target.has_revision(revision_id)):
2845
1686
"""Be compatible with Knit1 source and Knit3 target"""
2846
1687
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit3
2847
1688
try:
2848
from bzrlib.repofmt.knitrepo import (RepositoryFormatKnit1,
2849
RepositoryFormatKnit3)
2850
from bzrlib.repofmt.pack_repo import (
2851
RepositoryFormatKnitPack1,
2852
RepositoryFormatKnitPack3,
2853
RepositoryFormatPackDevelopment0,
2854
RepositoryFormatPackDevelopment0Subtree,
2855
)
2856
nosubtrees = (
2857
RepositoryFormatKnit1,
2858
RepositoryFormatKnitPack1,
2859
RepositoryFormatPackDevelopment0,
2860
)
2861
subtrees = (
2862
RepositoryFormatKnit3,
2863
RepositoryFormatKnitPack3,
2864
RepositoryFormatPackDevelopment0Subtree,
2865
)
2866
return (isinstance(source._format, nosubtrees) and
2867
isinstance(target._format, subtrees))
1689
from bzrlib.repofmt.knitrepo import RepositoryFormatKnit1, \
1690
RepositoryFormatKnit3
1691
return (isinstance(source._format, (RepositoryFormatKnit1)) and
1692
isinstance(target._format, (RepositoryFormatKnit3)))
2868
1693
except AttributeError:
2869
1694
return False
2870
1695
2871
1696
@needs_write_lock
2872
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
1697
def fetch(self, revision_id=None, pb=None):
2873
1698
"""See InterRepository.fetch()."""
2874
1699
from bzrlib.fetch import Knit1to2Fetcher
2875
1700
mutter("Using fetch logic to copy between %s(%s) and %s(%s)",
2876
1701
self.source, self.source._format, self.target,
2877
1702
self.target._format)
1703
# TODO: jam 20070210 This should be an assert, not a translate
1704
revision_id = osutils.safe_revision_id(revision_id)
2878
1705
f = Knit1to2Fetcher(to_repository=self.target,
2879
1706
from_repository=self.source,
2880
1707
last_revision=revision_id,
2881
pb=pb, find_ghosts=find_ghosts)
2882
return f.count_copied, f.failed_revisions
2883
2884
2885
class InterDifferingSerializer(InterKnitRepo):
2886
2887
@classmethod
2888
def _get_repo_format_to_test(self):
2889
return None
2890
2891
@staticmethod
2892
def is_compatible(source, target):
2893
"""Be compatible with Knit2 source and Knit3 target"""
2894
if source.supports_rich_root() != target.supports_rich_root():
2895
return False
2896
# Ideally, we'd support fetching if the source had no tree references
2897
# even if it supported them...
2898
if (getattr(source, '_format.supports_tree_reference', False) and
2899
not getattr(target, '_format.supports_tree_reference', False)):
2900
return False
2901
return True
2902
2903
@needs_write_lock
2904
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2905
"""See InterRepository.fetch()."""
2906
revision_ids = self.target.search_missing_revision_ids(self.source,
2907
revision_id, find_ghosts=find_ghosts).get_keys()
2908
revision_ids = tsort.topo_sort(
2909
self.source.get_graph().get_parent_map(revision_ids))
2910
def revisions_iterator():
2911
for current_revision_id in revision_ids:
2912
revision = self.source.get_revision(current_revision_id)
2913
tree = self.source.revision_tree(current_revision_id)
2914
try:
2915
signature = self.source.get_signature_text(
2916
current_revision_id)
2917
except errors.NoSuchRevision:
2918
signature = None
2919
yield revision, tree, signature
2920
if pb is None:
2921
my_pb = ui.ui_factory.nested_progress_bar()
2922
pb = my_pb
2923
else:
2924
my_pb = None
2925
try:
2926
install_revisions(self.target, revisions_iterator(),
2927
len(revision_ids), pb)
2928
finally:
2929
if my_pb is not None:
2930
my_pb.finished()
2931
return len(revision_ids), 0
2932
2933
2934
class InterRemoteToOther(InterRepository):
2935
2936
def __init__(self, source, target):
2937
InterRepository.__init__(self, source, target)
2938
self._real_inter = None
2939
2940
@staticmethod
2941
def is_compatible(source, target):
2942
if not isinstance(source, remote.RemoteRepository):
2943
return False
2944
# Is source's model compatible with target's model?
2945
source._ensure_real()
2946
real_source = source._real_repository
2947
assert not isinstance(real_source, remote.RemoteRepository), (
2948
"We don't support remote repos backed by remote repos yet.")
2949
return InterRepository._same_model(real_source, target)
2950
2951
@needs_write_lock
2952
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2953
"""See InterRepository.fetch()."""
2954
from bzrlib.fetch import RemoteToOtherFetcher
2955
mutter("Using fetch logic to copy between %s(remote) and %s(%s)",
2956
self.source, self.target, self.target._format)
2957
# TODO: jam 20070210 This should be an assert, not a translate
2958
revision_id = osutils.safe_revision_id(revision_id)
2959
f = RemoteToOtherFetcher(to_repository=self.target,
2960
from_repository=self.source,
2961
last_revision=revision_id,
2962
pb=pb, find_ghosts=find_ghosts)
2963
return f.count_copied, f.failed_revisions
2964
2965
@classmethod
2966
def _get_repo_format_to_test(self):
2967
return None
2968
2969
2970
class InterOtherToRemote(InterRepository):
2971
2972
def __init__(self, source, target):
2973
InterRepository.__init__(self, source, target)
2974
self._real_inter = None
2975
2976
@staticmethod
2977
def is_compatible(source, target):
1708
pb=pb)
1709
return f.count_copied, f.failed_revisions
1710
1711
1712
class InterRemoteRepository(InterRepository):
1713
"""Code for converting between RemoteRepository objects.
1714
1715
This just gets an non-remote repository from the RemoteRepository, and calls
1716
InterRepository.get again.
1717
"""
1718
1719
def __init__(self, source, target):
1720
if isinstance(source, remote.RemoteRepository):
1721
source._ensure_real()
1722
real_source = source._real_repository
1723
else:
1724
real_source = source
1725
if isinstance(target, remote.RemoteRepository):
1726
target._ensure_real()
1727
real_target = target._real_repository
1728
else:
1729
real_target = target
1730
self.real_inter = InterRepository.get(real_source, real_target)
1731
1732
@staticmethod
1733
def is_compatible(source, target):
1734
if isinstance(source, remote.RemoteRepository):
1735
return True
2978
1736
if isinstance(target, remote.RemoteRepository):
2979
1737
return True
2980
1738
return False
2981
1739
2982
def _ensure_real_inter(self):
2983
if self._real_inter is None:
2984
self.target._ensure_real()
2985
real_target = self.target._real_repository
2986
self._real_inter = InterRepository.get(self.source, real_target)
2987
2988
1740
def copy_content(self, revision_id=None):
2989
self._ensure_real_inter()
2990
self._real_inter.copy_content(revision_id=revision_id)
1741
self.real_inter.copy_content(revision_id=revision_id)
2991
1742
2992
def fetch(self, revision_id=None, pb=None, find_ghosts=False):
2993
self._ensure_real_inter()
2994
self._real_inter.fetch(revision_id=revision_id, pb=pb,
2995
find_ghosts=find_ghosts)
1743
def fetch(self, revision_id=None, pb=None):
1744
self.real_inter.fetch(revision_id=revision_id, pb=pb)
2996
1745
2997
1746
@classmethod
2998
1747
def _get_repo_format_to_test(self):
2999
1748
return None
3000
1749
3001
1750
3002
InterRepository.register_optimiser(InterDifferingSerializer)
3003
1751
InterRepository.register_optimiser(InterSameDataRepository)
3004
1752
InterRepository.register_optimiser(InterWeaveRepo)
3005
1753
InterRepository.register_optimiser(InterKnitRepo)
3006
1754
InterRepository.register_optimiser(InterModel1and2)
3007
1755
InterRepository.register_optimiser(InterKnit1and2)
3008
InterRepository.register_optimiser(InterPackRepo)
3009
InterRepository.register_optimiser(InterRemoteToOther)
3010
InterRepository.register_optimiser(InterOtherToRemote)
1756
InterRepository.register_optimiser(InterRemoteRepository)
1757
1758
1759
class RepositoryTestProviderAdapter(object):
1760
"""A tool to generate a suite testing multiple repository formats at once.
1761
1762
This is done by copying the test once for each transport and injecting
1763
the transport_server, transport_readonly_server, and bzrdir_format and
1764
repository_format classes into each copy. Each copy is also given a new id()
1765
to make it easy to identify.
1766
"""
1767
1768
def __init__(self, transport_server, transport_readonly_server, formats,
1769
vfs_transport_factory=None):
1770
self._transport_server = transport_server
1771
self._transport_readonly_server = transport_readonly_server
1772
self._vfs_transport_factory = vfs_transport_factory
1773
self._formats = formats
1774
1775
def adapt(self, test):
1776
result = unittest.TestSuite()
1777
for repository_format, bzrdir_format in self._formats:
1778
from copy import deepcopy
1779
new_test = deepcopy(test)
1780
new_test.transport_server = self._transport_server
1781
new_test.transport_readonly_server = self._transport_readonly_server
1782
# Only override the test's vfs_transport_factory if one was
1783
# specified, otherwise just leave the default in place.
1784
if self._vfs_transport_factory:
1785
new_test.vfs_transport_factory = self._vfs_transport_factory
1786
new_test.bzrdir_format = bzrdir_format
1787
new_test.repository_format = repository_format
1788
def make_new_test_id():
1789
new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
1790
return lambda: new_id
1791
new_test.id = make_new_test_id()
1792
result.addTest(new_test)
1793
return result
1794
1795
1796
class InterRepositoryTestProviderAdapter(object):
1797
"""A tool to generate a suite testing multiple inter repository formats.
1798
1799
This is done by copying the test once for each interrepo provider and injecting
1800
the transport_server, transport_readonly_server, repository_format and
1801
repository_to_format classes into each copy.
1802
Each copy is also given a new id() to make it easy to identify.
1803
"""
1804
1805
def __init__(self, transport_server, transport_readonly_server, formats):
1806
self._transport_server = transport_server
1807
self._transport_readonly_server = transport_readonly_server
1808
self._formats = formats
1809
1810
def adapt(self, test):
1811
result = unittest.TestSuite()
1812
for interrepo_class, repository_format, repository_format_to in self._formats:
1813
from copy import deepcopy
1814
new_test = deepcopy(test)
1815
new_test.transport_server = self._transport_server
1816
new_test.transport_readonly_server = self._transport_readonly_server
1817
new_test.interrepo_class = interrepo_class
1818
new_test.repository_format = repository_format
1819
new_test.repository_format_to = repository_format_to
1820
def make_new_test_id():
1821
new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
1822
return lambda: new_id
1823
new_test.id = make_new_test_id()
1824
result.addTest(new_test)
1825
return result
1826
1827
@staticmethod
1828
def default_test_list():
1829
"""Generate the default list of interrepo permutations to test."""
1830
from bzrlib.repofmt import knitrepo, weaverepo
1831
result = []
1832
# test the default InterRepository between format 6 and the current
1833
# default format.
1834
# XXX: robertc 20060220 reinstate this when there are two supported
1835
# formats which do not have an optimal code path between them.
1836
#result.append((InterRepository,
1837
# RepositoryFormat6(),
1838
# RepositoryFormatKnit1()))
1839
for optimiser_class in InterRepository._optimisers:
1840
format_to_test = optimiser_class._get_repo_format_to_test()
1841
if format_to_test is not None:
1842
result.append((optimiser_class,
1843
format_to_test, format_to_test))
1844
# if there are specific combinations we want to use, we can add them
1845
# here.
1846
result.append((InterModel1and2,
1847
weaverepo.RepositoryFormat5(),
1848
knitrepo.RepositoryFormatKnit3()))
1849
result.append((InterKnit1and2,
1850
knitrepo.RepositoryFormatKnit1(),
1851
knitrepo.RepositoryFormatKnit3()))
1852
return result
3011
1853
3012
1854
3013
1855
class CopyConverter(object):
3062
1904
self.pb.update(message, self.count, self.total)
3063
1905
3064
1906
1907
class CommitBuilder(object):
1908
"""Provides an interface to build up a commit.
1909
1910
This allows describing a tree to be committed without needing to
1911
know the internals of the format of the repository.
1912
"""
1913
1914
record_root_entry = False
1915
def __init__(self, repository, parents, config, timestamp=None,
1916
timezone=None, committer=None, revprops=None,
1917
revision_id=None):
1918
"""Initiate a CommitBuilder.
1919
1920
:param repository: Repository to commit to.
1921
:param parents: Revision ids of the parents of the new revision.
1922
:param config: Configuration to use.
1923
:param timestamp: Optional timestamp recorded for commit.
1924
:param timezone: Optional timezone for timestamp.
1925
:param committer: Optional committer to set for commit.
1926
:param revprops: Optional dictionary of revision properties.
1927
:param revision_id: Optional revision id.
1928
"""
1929
self._config = config
1930
1931
if committer is None:
1932
self._committer = self._config.username()
1933
else:
1934
assert isinstance(committer, basestring), type(committer)
1935
self._committer = committer
1936
1937
self.new_inventory = Inventory(None)
1938
self._new_revision_id = osutils.safe_revision_id(revision_id)
1939
self.parents = parents
1940
self.repository = repository
1941
1942
self._revprops = {}
1943
if revprops is not None:
1944
self._revprops.update(revprops)
1945
1946
if timestamp is None:
1947
timestamp = time.time()
1948
# Restrict resolution to 1ms
1949
self._timestamp = round(timestamp, 3)
1950
1951
if timezone is None:
1952
self._timezone = osutils.local_time_offset()
1953
else:
1954
self._timezone = int(timezone)
1955
1956
self._generate_revision_if_needed()
1957
1958
def commit(self, message):
1959
"""Make the actual commit.
1960
1961
:return: The revision id of the recorded revision.
1962
"""
1963
rev = _mod_revision.Revision(
1964
timestamp=self._timestamp,
1965
timezone=self._timezone,
1966
committer=self._committer,
1967
message=message,
1968
inventory_sha1=self.inv_sha1,
1969
revision_id=self._new_revision_id,
1970
properties=self._revprops)
1971
rev.parent_ids = self.parents
1972
self.repository.add_revision(self._new_revision_id, rev,
1973
self.new_inventory, self._config)
1974
return self._new_revision_id
1975
1976
def revision_tree(self):
1977
"""Return the tree that was just committed.
1978
1979
After calling commit() this can be called to get a RevisionTree
1980
representing the newly committed tree. This is preferred to
1981
calling Repository.revision_tree() because that may require
1982
deserializing the inventory, while we already have a copy in
1983
memory.
1984
"""
1985
return RevisionTree(self.repository, self.new_inventory,
1986
self._new_revision_id)
1987
1988
def finish_inventory(self):
1989
"""Tell the builder that the inventory is finished."""
1990
if self.new_inventory.root is None:
1991
symbol_versioning.warn('Root entry should be supplied to'
1992
' record_entry_contents, as of bzr 0.10.',
1993
DeprecationWarning, stacklevel=2)
1994
self.new_inventory.add(InventoryDirectory(ROOT_ID, '', None))
1995
self.new_inventory.revision_id = self._new_revision_id
1996
self.inv_sha1 = self.repository.add_inventory(
1997
self._new_revision_id,
1998
self.new_inventory,
1999
self.parents
2000
)
2001
2002
def _gen_revision_id(self):
2003
"""Return new revision-id."""
2004
return generate_ids.gen_revision_id(self._config.username(),
2005
self._timestamp)
2006
2007
def _generate_revision_if_needed(self):
2008
"""Create a revision id if None was supplied.
2009
2010
If the repository can not support user-specified revision ids
2011
they should override this function and raise CannotSetRevisionId
2012
if _new_revision_id is not None.
2013
2014
:raises: CannotSetRevisionId
2015
"""
2016
if self._new_revision_id is None:
2017
self._new_revision_id = self._gen_revision_id()
2018
2019
def record_entry_contents(self, ie, parent_invs, path, tree):
2020
"""Record the content of ie from tree into the commit if needed.
2021
2022
Side effect: sets ie.revision when unchanged
2023
2024
:param ie: An inventory entry present in the commit.
2025
:param parent_invs: The inventories of the parent revisions of the
2026
commit.
2027
:param path: The path the entry is at in the tree.
2028
:param tree: The tree which contains this entry and should be used to
2029
obtain content.
2030
"""
2031
if self.new_inventory.root is None and ie.parent_id is not None:
2032
symbol_versioning.warn('Root entry should be supplied to'
2033
' record_entry_contents, as of bzr 0.10.',
2034
DeprecationWarning, stacklevel=2)
2035
self.record_entry_contents(tree.inventory.root.copy(), parent_invs,
2036
'', tree)
2037
self.new_inventory.add(ie)
2038
2039
# ie.revision is always None if the InventoryEntry is considered
2040
# for committing. ie.snapshot will record the correct revision
2041
# which may be the sole parent if it is untouched.
2042
if ie.revision is not None:
2043
return
2044
2045
# In this revision format, root entries have no knit or weave
2046
if ie is self.new_inventory.root:
2047
# When serializing out to disk and back in
2048
# root.revision is always _new_revision_id
2049
ie.revision = self._new_revision_id
2050
return
2051
previous_entries = ie.find_previous_heads(
2052
parent_invs,
2053
self.repository.weave_store,
2054
self.repository.get_transaction())
2055
# we are creating a new revision for ie in the history store
2056
# and inventory.
2057
ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
2058
2059
def modified_directory(self, file_id, file_parents):
2060
"""Record the presence of a symbolic link.
2061
2062
:param file_id: The file_id of the link to record.
2063
:param file_parents: The per-file parent revision ids.
2064
"""
2065
self._add_text_to_weave(file_id, [], file_parents.keys())
2066
2067
def modified_reference(self, file_id, file_parents):
2068
"""Record the modification of a reference.
2069
2070
:param file_id: The file_id of the link to record.
2071
:param file_parents: The per-file parent revision ids.
2072
"""
2073
self._add_text_to_weave(file_id, [], file_parents.keys())
2074
2075
def modified_file_text(self, file_id, file_parents,
2076
get_content_byte_lines, text_sha1=None,
2077
text_size=None):
2078
"""Record the text of file file_id
2079
2080
:param file_id: The file_id of the file to record the text of.
2081
:param file_parents: The per-file parent revision ids.
2082
:param get_content_byte_lines: A callable which will return the byte
2083
lines for the file.
2084
:param text_sha1: Optional SHA1 of the file contents.
2085
:param text_size: Optional size of the file contents.
2086
"""
2087
# mutter('storing text of file {%s} in revision {%s} into %r',
2088
# file_id, self._new_revision_id, self.repository.weave_store)
2089
# special case to avoid diffing on renames or
2090
# reparenting
2091
if (len(file_parents) == 1
2092
and text_sha1 == file_parents.values()[0].text_sha1
2093
and text_size == file_parents.values()[0].text_size):
2094
previous_ie = file_parents.values()[0]
2095
versionedfile = self.repository.weave_store.get_weave(file_id,
2096
self.repository.get_transaction())
2097
versionedfile.clone_text(self._new_revision_id,
2098
previous_ie.revision, file_parents.keys())
2099
return text_sha1, text_size
2100
else:
2101
new_lines = get_content_byte_lines()
2102
# TODO: Rather than invoking sha_strings here, _add_text_to_weave
2103
# should return the SHA1 and size
2104
self._add_text_to_weave(file_id, new_lines, file_parents.keys())
2105
return osutils.sha_strings(new_lines), \
2106
sum(map(len, new_lines))
2107
2108
def modified_link(self, file_id, file_parents, link_target):
2109
"""Record the presence of a symbolic link.
2110
2111
:param file_id: The file_id of the link to record.
2112
:param file_parents: The per-file parent revision ids.
2113
:param link_target: Target location of this link.
2114
"""
2115
self._add_text_to_weave(file_id, [], file_parents.keys())
2116
2117
def _add_text_to_weave(self, file_id, new_lines, parents):
2118
versionedfile = self.repository.weave_store.get_weave_or_empty(
2119
file_id, self.repository.get_transaction())
2120
versionedfile.add_lines(self._new_revision_id, parents, new_lines)
2121
versionedfile.clear_cache()
2122
2123
2124
class _CommitBuilder(CommitBuilder):
2125
"""Temporary class so old CommitBuilders are detected properly
2126
2127
Note: CommitBuilder works whether or not root entry is recorded.
2128
"""
2129
2130
record_root_entry = True
2131
2132
2133
class RootCommitBuilder(CommitBuilder):
2134
"""This commitbuilder actually records the root id"""
2135
2136
record_root_entry = True
2137
2138
def record_entry_contents(self, ie, parent_invs, path, tree):
2139
"""Record the content of ie from tree into the commit if needed.
2140
2141
Side effect: sets ie.revision when unchanged
2142
2143
:param ie: An inventory entry present in the commit.
2144
:param parent_invs: The inventories of the parent revisions of the
2145
commit.
2146
:param path: The path the entry is at in the tree.
2147
:param tree: The tree which contains this entry and should be used to
2148
obtain content.
2149
"""
2150
assert self.new_inventory.root is not None or ie.parent_id is None
2151
self.new_inventory.add(ie)
2152
2153
# ie.revision is always None if the InventoryEntry is considered
2154
# for committing. ie.snapshot will record the correct revision
2155
# which may be the sole parent if it is untouched.
2156
if ie.revision is not None:
2157
return
2158
2159
previous_entries = ie.find_previous_heads(
2160
parent_invs,
2161
self.repository.weave_store,
2162
self.repository.get_transaction())
2163
# we are creating a new revision for ie in the history store
2164
# and inventory.
2165
ie.snapshot(self._new_revision_id, path, previous_entries, tree, self)
2166
2167
3065
2168
_unescape_map = {
3066
2169
'apos':"'",
3067
2170
'quot':'"',
3090
2193
if _unescape_re is None:
3091
2194
_unescape_re = re.compile('\&([^;]*);')
3092
2195
return _unescape_re.sub(_unescaper, data)
3093
3094
3095
class _VersionedFileChecker(object):
3096
3097
def __init__(self, repository):
3098
self.repository = repository
3099
self.text_index = self.repository._generate_text_key_index()
3100
3101
def calculate_file_version_parents(self, revision_id, file_id):
3102
"""Calculate the correct parents for a file version according to
3103
the inventories.
3104
"""
3105
parent_keys = self.text_index[(file_id, revision_id)]
3106
if parent_keys == [_mod_revision.NULL_REVISION]:
3107
return ()
3108
# strip the file_id, for the weave api
3109
return tuple([revision_id for file_id, revision_id in parent_keys])
3110
3111
def check_file_version_parents(self, weave, file_id):
3112
"""Check the parents stored in a versioned file are correct.
3113
3114
It also detects file versions that are not referenced by their
3115
corresponding revision's inventory.
3116
3117
:returns: A tuple of (wrong_parents, dangling_file_versions).
3118
wrong_parents is a dict mapping {revision_id: (stored_parents,
3119
correct_parents)} for each revision_id where the stored parents
3120
are not correct. dangling_file_versions is a set of (file_id,
3121
revision_id) tuples for versions that are present in this versioned
3122
file, but not used by the corresponding inventory.
3123
"""
3124
wrong_parents = {}
3125
unused_versions = set()
3126
versions = weave.versions()
3127
parent_map = weave.get_parent_map(versions)
3128
for num, revision_id in enumerate(versions):
3129
try:
3130
correct_parents = self.calculate_file_version_parents(
3131
revision_id, file_id)
3132
except KeyError:
3133
# The version is not part of the used keys.
3134
unused_versions.add(revision_id)
3135
else:
3136
try:
3137
knit_parents = tuple(parent_map[revision_id])
3138
except errors.RevisionNotPresent:
3139
knit_parents = None
3140
if correct_parents != knit_parents:
3141
wrong_parents[revision_id] = (knit_parents, correct_parents)
3142
return wrong_parents, unused_versions
3143
3144
3145
def _old_get_graph(repository, revision_id):
3146
"""DO NOT USE. That is all. I'm serious."""
3147
graph = repository.get_graph()
3148
revision_graph = dict(((key, value) for key, value in
3149
graph.iter_ancestry([revision_id]) if value is not None))
3150
return _strip_NULL_ghosts(revision_graph)
3151
3152
3153
def _strip_NULL_ghosts(revision_graph):
3154
"""Also don't use this. more compatibility code for unmigrated clients."""
3155
# Filter ghosts, and null:
3156
if _mod_revision.NULL_REVISION in revision_graph:
3157
del revision_graph[_mod_revision.NULL_REVISION]
3158
for key, parents in revision_graph.items():
3159
revision_graph[key] = tuple(parent for parent in parents if parent
3160
in revision_graph)
3161
return revision_graph
Loggerhead is a web-based interface for Breezy
Version: 2.0.1